send command

Cargo.toml

@@ -16,7 +16,7 @@ anyhow = { version = "1.0.56", features = ["backtrace"] }
 axum = "0.5.6"
 axum-server = "0.4.0"
 bitcoin = "0.29.1"
-bitcoincore-rpc = "0.16.0"
+bitcoincore-rpc = { version = "0.16.0", git = "https://github.com/casey/rust-bitcoincore-rpc", branch = "ord" }
 boilerplate = { version = "0.2.1", features = ["axum"] }
 chrono = "0.4.19"
 clap = { version = "3.1.0", features = ["derive"] }

src/options.rs

@@ -23,6 +23,11 @@ pub(crate) struct Options {
   bitcoin_data_dir: Option<PathBuf>,
   #[clap(long, help = "Limit index to <HEIGHT_LIMIT> blocks.")]
   pub(crate) height_limit: Option<u64>,
+  #[clap(
+    long,
+    help = "Add this flag to use the send functionality of the wallet."
+  )]
+  pub(crate) reckless: bool,
 }
 
 #[derive(ValueEnum, Copy, Clone, Debug)]

src/subcommand/wallet.rs

@@ -2,6 +2,7 @@ use {super::*, bitcoincore_rpc::RpcApi};
 
 mod identify;
 mod list;
+mod send;
 
 fn list_unspent(options: Options) -> Result<Vec<(OutPoint, Vec<(u64, u64)>)>> {
   let index = Index::open(&options)?;
@@ -27,13 +28,15 @@ fn list_unspent(options: Options) -> Result<Vec<(OutPoint, Vec<(u64, u64)>)>> {
 pub(crate) enum Wallet {
   Identify,
   List,
+  Send(send::Send),
 }
 
 impl Wallet {
   pub(crate) fn run(self, options: Options) -> Result<()> {
     match self {
       Self::Identify => identify::run(options),
       Self::List => list::run(options),
+      Self::Send(send) => send.run(options),
     }
   }
 }

src/subcommand/wallet/send.rs

@@ -0,0 +1,47 @@
+use {
+  super::*, bitcoin::util::amount::Amount, bitcoincore_rpc::json::CreateRawTransactionInput,
+  std::collections::HashMap,
+};
+
+#[derive(Debug, Parser)]
+pub(crate) struct Send {
+  ordinal: Ordinal,
+  address: String,
+}
+
+impl Send {
+  pub(crate) fn run(self, options: Options) -> Result {
+    if options.chain.network() == Network::Bitcoin {
+      bail!("Send command is not allowed on mainnet yet. Try on regtest/signet/testnet.")
+    }
+
+    let index = Index::open(&options)?;
+    index.index()?;
+
+    let satpoint = index.find(self.ordinal.0)?.unwrap();
+    let output = satpoint.outpoint;
+
+    let client = options.bitcoin_rpc_client()?;
+
+    let amount = client
+      .get_transaction(&output.txid, Some(true))?
+      .amount
+      .to_sat() as u64;
+
+    let inputs = vec![CreateRawTransactionInput {
+      txid: output.txid,
+      vout: output.vout,
+      sequence: None,
+    }];
+
+    let mut outputs = HashMap::new();
+    outputs.insert(self.address, Amount::from_sat(amount));
+
+    let tx = client.create_raw_transaction_hex(&inputs, &outputs, None, None)?;
+    let signed_tx = client.sign_raw_transaction_with_wallet(tx, None, None)?.hex;
+    let txid = client.send_raw_transaction(&signed_tx)?;
+
+    println!("{txid}");
+    Ok(())
+  }
+}

test-bitcoincore-rpc/Cargo.toml

@@ -9,8 +9,7 @@ repository = "https://github.com/casey/ord"
 
 [dependencies]
 bitcoin = { version = "0.29.1", features = ["serde"] }
-bitcoincore-rpc = "0.16.0"
-bitcoincore-rpc-json = "0.16.0"
+bitcoincore-rpc = { version = "0.16.0", git = "https://github.com/casey/rust-bitcoincore-rpc", branch = "ord" }
 hex = "0.4.3"
 jsonrpc-core = "18.0.0"
 jsonrpc-core-client = "18.0.0"

test-bitcoincore-rpc/src/lib.rs

@@ -1,14 +1,23 @@
 use {
   bitcoin::{
-    blockdata::constants::COIN_VALUE, blockdata::script, consensus::encode::serialize,
-    hash_types::BlockHash, hashes::Hash, Amount, Block, BlockHeader, Network, OutPoint,
-    PackedLockTime, Script, Sequence, Transaction, TxIn, TxMerkleNode, TxOut, Txid, Witness, Wtxid,
+    blockdata::constants::COIN_VALUE,
+    blockdata::script,
+    consensus::encode::{deserialize, serialize},
+    hash_types::BlockHash,
+    hashes::Hash,
+    util::amount::SignedAmount,
+    Amount, Block, BlockHeader, Network, OutPoint, PackedLockTime, Script, Sequence, Transaction,
+    TxIn, TxMerkleNode, TxOut, Txid, Witness, Wtxid,
+  },
+  bitcoincore_rpc::json::{
+    Bip125Replaceable, CreateRawTransactionInput, GetBlockHeaderResult, GetRawTransactionResult,
+    GetTransactionResult, ListUnspentResultEntry, SignRawTransactionResult, WalletTxInfo,
   },
-  bitcoincore_rpc_json::{GetBlockHeaderResult, GetRawTransactionResult, ListUnspentResultEntry},
   jsonrpc_core::{IoHandler, Value},
   jsonrpc_http_server::{CloseHandle, ServerBuilder},
   std::collections::BTreeMap,
   std::{
+    collections::HashMap,
     sync::{Arc, Mutex, MutexGuard},
     thread,
   },
@@ -206,6 +215,33 @@ pub trait Api {
   #[rpc(name = "getblock")]
   fn getblock(&self, blockhash: BlockHash, verbosity: u64) -> Result<String, jsonrpc_core::Error>;
 
+  #[rpc(name = "createrawtransaction")]
+  fn create_raw_transaction(
+    &self,
+    utxos: Vec<CreateRawTransactionInput>,
+    outs: HashMap<String, f64>,
+    locktime: Option<i64>,
+    replaceable: Option<bool>,
+  ) -> Result<String, jsonrpc_core::Error>;
+
+  #[rpc(name = "signrawtransactionwithwallet")]
+  fn sign_raw_transaction_with_wallet(
+    &self,
+    tx: String,
+    utxos: Option<()>,
+    sighash_type: Option<()>,
+  ) -> Result<Value, jsonrpc_core::Error>;
+
+  #[rpc(name = "sendrawtransaction")]
+  fn send_raw_transaction(&self, tx: String) -> Result<String, jsonrpc_core::Error>;
+
+  #[rpc(name = "gettransaction")]
+  fn get_transaction(
+    &self,
+    txid: Txid,
+    include_watchonly: Option<bool>,
+  ) -> Result<Value, jsonrpc_core::Error>;
+
   #[rpc(name = "getrawtransaction")]
   fn get_raw_transaction(
     &self,
@@ -285,6 +321,99 @@ impl Api for Server {
     }
   }
 
+  fn create_raw_transaction(
+    &self,
+    utxos: Vec<CreateRawTransactionInput>,
+    outs: HashMap<String, f64>,
+    locktime: Option<i64>,
+    replaceable: Option<bool>,
+  ) -> Result<String, jsonrpc_core::Error> {
+    assert_eq!(locktime, None, "locktime param not supported");
+    assert_eq!(replaceable, None, "replaceable param not supported");
+
+    let tx = Transaction {
+      version: 0,
+      lock_time: PackedLockTime(0),
+      input: utxos
+        .iter()
+        .map(|input| TxIn {
+          previous_output: OutPoint::new(input.txid, input.vout),
+          script_sig: Script::new(),
+          sequence: Sequence(0),
+          witness: Witness::new(),
+        })
+        .collect(),
+      output: outs
+        .iter()
+        .map(|(_address, amount)| TxOut {
+          value: *amount as u64,
+          script_pubkey: Script::new(),
+        })
+        .collect(),
+    };
+
+    Ok(hex::encode(serialize(&tx)))
+  }
+
+  fn sign_raw_transaction_with_wallet(
+    &self,
+    tx: String,
+    utxos: Option<()>,
+    sighash_type: Option<()>,
+  ) -> Result<Value, jsonrpc_core::Error> {
+    assert_eq!(utxos, None, "utxos param not supported");
+    assert_eq!(sighash_type, None, "sighash_type param not supported");
+
+    Ok(
+      serde_json::to_value(SignRawTransactionResult {
+        hex: hex::decode(tx).unwrap(),
+        complete: true,
+        errors: None,
+      })
+      .unwrap(),
+    )
+  }
+
+  fn send_raw_transaction(&self, tx: String) -> Result<String, jsonrpc_core::Error> {
+    let tx: Transaction = deserialize(&hex::decode(tx).unwrap()).unwrap();
+    self.state.lock().unwrap().mempool.push(tx.clone());
+
+    Ok(tx.txid().to_string())
+  }
+
+  fn get_transaction(
+    &self,
+    txid: Txid,
+    _include_watchonly: Option<bool>,
+  ) -> Result<Value, jsonrpc_core::Error> {
+    match self.state.lock().unwrap().transactions.get(&txid) {
+      Some(tx) => Ok(
+        serde_json::to_value(GetTransactionResult {
+          info: WalletTxInfo {
+            txid,
+            confirmations: 0,
+            time: 0,
+            timereceived: 0,
+            blockhash: None,
+            blockindex: None,
+            blockheight: None,
+            blocktime: None,
+            wallet_conflicts: Vec::new(),
+            bip125_replaceable: Bip125Replaceable::Unknown,
+          },
+          amount: SignedAmount::from_sat(0),
+          fee: None,
+          details: Vec::new(),
+          hex: serialize(tx),
+        })
+        .unwrap(),
+      ),
+      None => Err(jsonrpc_core::Error::new(
+        jsonrpc_core::types::error::ErrorCode::ServerError(-8),
+      )),
+    }
+  }
+
   fn get_raw_transaction(
     &self,
     txid: Txid,

tests/command_builder.rs

@@ -120,8 +120,10 @@ impl CommandBuilder {
     self.tempdir
   }
 
-  pub(crate) fn run(self) -> TempDir {
+  pub(crate) fn run(self) -> (TempDir, String) {
     let output = self.command().output().unwrap();
-    self.check(output)
+    let str_output = String::from(str::from_utf8(&output.stdout).unwrap());
+
+    (self.check(output), str_output)
   }
 }