Addition of new RPC command for manual cpfp.

Along with tests.

Author: Zshan0

doc/API.md

@@ -26,6 +26,7 @@ Note that all addresses are bech32-encoded *version 0* native Segwit `scriptPubK
 | [`setspendtx`](#setspendtx)                                 | Announce and broadcast this Spend transaction        |
 | [`gethistory`](#gethistory)                                 | Retrieve history of funds                            |
 | [`emergency`](#emergency)                                   | Broadcast all Emergency signed transactions          |
+| [`cpfp`](#cpfp)                                             | Manually trigger the cpfp for transactions.          |
 
 
 
@@ -483,6 +484,20 @@ of inflows and outflows net of any change amount (that is technically a transact
 None; the `result` field will be set to the empty object `{}`. Any value should be
 disregarded for forward compatibility.
 
+### `cpfp`
+
+#### Request
+
+| Field          | Type   | Description                                    |
+| -------------- | ------ | ---------------------------------------------- |
+| `txids`        | array  | Array of Txids that must be CPFPed             |
+| `feerate`      | float  | The new target feerate.                        |
+
+#### Response
+
+None; the `result` field will be set to the empty object `{}`. Any value should be
+disregarded for forward compatibility.
+
 
 ## User flows
 

src/bitcoind/mod.rs

@@ -3,9 +3,17 @@ pub mod poller;
 pub mod utils;
 
 use crate::config::BitcoindConfig;
-use crate::{database::DatabaseError, revaultd::RevaultD, threadmessages::BitcoindMessageOut};
+use crate::{
+    commands::CommandError,
+    database::{
+        interface::{db_spend_transaction, db_unvault_transaction_by_txid},
+        DatabaseError,
+    },
+    revaultd::RevaultD,
+    threadmessages::BitcoindMessageOut,
+};
 use interface::{BitcoinD, WalletTransaction};
-use poller::poller_main;
+use poller::{cpfp_package, poller_main, should_cpfp, ToBeCpfped};
 use revault_tx::bitcoin::{Network, Txid};
 
 use std::{
@@ -187,6 +195,61 @@ fn wallet_transaction(bitcoind: &BitcoinD, txid: Txid) -> Option<WalletTransacti
         .ok()
 }
 
+fn cpfp(
+    revaultd: Arc<RwLock<RevaultD>>,
+    bitcoind: Arc<RwLock<BitcoinD>>,
+    txids: Vec<Txid>,
+    feerate: f64,
+) -> Result<Vec<Txid>, CommandError> {
+    let db_path = revaultd.read().unwrap().db_file();
+    assert!(revaultd.read().unwrap().is_manager());
+
+    let mut cpfp_txs = Vec::with_capacity(txids.len());
+    let mut cpfp_txids = Vec::with_capacity(txids.len());
+
+    // sats/vbyte -> sats/WU
+    let sats_wu = feerate / 4.0;
+
+    // sats/WU -> sats/kWU
+    let sats_kwu = (sats_wu * 1000.0) as u64;
+
+    for txid in txids.iter() {
+        let spend_tx = db_spend_transaction(&db_path, &txid).expect("Database must be available");
+
+        if let Some(unwrap_spend_tx) = spend_tx {
+            // If the transaction is of type SpendTransaction
+            let psbt = unwrap_spend_tx.psbt;
+            if should_cpfp(&bitcoind.read().unwrap(), &psbt, sats_kwu) {
+                cpfp_txs.push(ToBeCpfped::Spend(psbt));
+                cpfp_txids.push(txid.clone());
+            }
+        } else {
+            let unvault_tx = match db_unvault_transaction_by_txid(&db_path, &txid)
+                .expect("Database must be available")
+            {
+                Some(tx) => tx,
+                None => return Err(CommandError::InvalidParams("Unknown Txid.".to_string())),
+            };
+            // The transaction type is asserted to be UnvaultTransaction
+            let psbt = unvault_tx.psbt.assert_unvault();
+            if should_cpfp(&bitcoind.read().unwrap(), &psbt, sats_kwu) {
+                cpfp_txs.push(ToBeCpfped::Unvault(psbt));
+                cpfp_txids.push(txid.clone());
+            }
+        }
+    }
+
+    if cpfp_txids.len() > 0 {
+        match cpfp_package(&revaultd, &bitcoind.read().unwrap(), cpfp_txs, sats_kwu) {
+            Err(err) => return Err(CommandError::Bitcoind(err)),
+            _ => {}
+        }
+    } else {
+        log::info!("Nothing to CPFP in the given list.");
+    }
+    Ok(cpfp_txids)
+}
+
 /// The bitcoind event loop.
 /// Listens for bitcoind requests (wallet / chain) and poll bitcoind every 30 seconds,
 /// updating our state accordingly.
@@ -208,7 +271,8 @@ pub fn bitcoind_main_loop(
         let _bitcoind = bitcoind.clone();
         let _sync_progress = sync_progress.clone();
         let _shutdown = shutdown.clone();
-        move || poller_main(revaultd, _bitcoind, _sync_progress, _shutdown)
+        let _revaultd = revaultd.clone();
+        move || poller_main(_revaultd, _bitcoind, _sync_progress, _shutdown)
     });
 
     for msg in rx {
@@ -252,6 +316,23 @@ pub fn bitcoind_main_loop(
                         ))
                     })?;
             }
+            BitcoindMessageOut::CPFPTransaction(txids, feerate, resp_tx) => {
+                log::trace!("Received 'cpfptransaction' from main thread");
+
+                let _bitcoind = bitcoind.clone();
+                let _revaultd = revaultd.clone();
+                resp_tx
+                    .send(
+                        cpfp(_revaultd, _bitcoind, txids, feerate)
+                            .map(|_v| {})
+                            .map_err(|e| {
+                                BitcoindError::Custom(format!("Error CPFPing transactions: {}", e))
+                            }),
+                    )
+                    .map_err(|e| {
+                        BitcoindError::Custom(format!("Sending transaction for CPFP: {}", e))
+                    })?;
+            }
         }
     }
 

src/bitcoind/poller.rs

@@ -408,7 +408,7 @@ fn mark_confirmed_emers(
     Ok(())
 }
 
-enum ToBeCpfped {
+pub enum ToBeCpfped {
     Spend(SpendTransaction),
     Unvault(UnvaultTransaction),
 }
@@ -447,10 +447,10 @@ impl ToBeCpfped {
     }
 }
 
-// CPFP a bunch of transactions, bumping their feerate by at least `target_feerate`.
-// `target_feerate` is expressed in sat/kWU.
-// All the transactions' feerate MUST be below `target_feerate`.
-fn cpfp_package(
+/// CPFP a bunch of transactions, bumping their feerate by at least `target_feerate`.
+/// `target_feerate` is expressed in sat/kWU.
+/// All the transactions' feerate MUST be below `target_feerate`.
+pub fn cpfp_package(
     revaultd: &Arc<RwLock<RevaultD>>,
     bitcoind: &BitcoinD,
     to_be_cpfped: Vec<ToBeCpfped>,
@@ -540,8 +540,12 @@ fn cpfp_package(
     Ok(())
 }
 
-// `target_feerate` is in sats/kWU
-fn should_cpfp(bitcoind: &BitcoinD, tx: &impl CpfpableTransaction, target_feerate: u64) -> bool {
+/// `target_feerate` is in sats/kWU
+pub fn should_cpfp(
+    bitcoind: &BitcoinD,
+    tx: &impl CpfpableTransaction,
+    target_feerate: u64,
+) -> bool {
     bitcoind
         .get_wallet_transaction(&tx.txid())
         // In the unlikely (actually, shouldn't happen but hey) case where

src/commands/mod.rs

@@ -1443,6 +1443,23 @@ impl DaemonControl {
         let revaultd = self.revaultd.read().unwrap();
         gethistory(&revaultd, &self.bitcoind_conn, start, end, limit, kind)
     }
+
+    /// Manually trigger a CPFP for the given transaction ID.
+    ///
+    /// ## Errors
+    /// - we don't have access to a CPFP private key
+    /// - the caller is not a manager
+    pub fn manual_cpfp(&self, txids: &Vec<Txid>, feerate: f64) -> Result<(), CommandError> {
+        let revaultd = self.revaultd.read().unwrap();
+
+        if revaultd.cpfp_key.is_none() {
+            return Err(CommandError::MissingCpfpKey);
+        }
+        manager_only!(revaultd);
+
+        self.bitcoind_conn.cpfp_tx(txids.to_vec(), feerate)?;
+        Ok(())
+    }
 }
 
 /// Descriptors the daemon was configured with

src/database/interface.rs

@@ -559,6 +559,7 @@ pub fn db_unvault_from_deposit(
 }
 
 /// Get a Cancel transaction by its transaction id.
+// [ZEE]
 pub fn db_cancel_transaction_by_txid(
     db_path: &Path,
     txid: &Txid,
@@ -606,6 +607,41 @@ pub fn db_unvault_emer_transaction(
     .map(|mut rows| rows.pop())
 }
 
+/// Get the Unvault transaction out of an Unvault txid
+pub fn db_unvault_transaction_by_txid(
+    db_path: &Path,
+    txid: &Txid,
+) -> Result<Option<DbTransaction>, DatabaseError> {
+    Ok(db_query(
+        db_path,
+        "SELECT vaults.*, ptx.id, ptx.psbt, ptx.fullysigned FROM presigned_transactions as ptx \
+         INNER JOIN vaults ON vaults.id = ptx.vault_id \
+         WHERE ptx.txid = (?1) and type = (?2)",
+        params![txid.to_vec(), TransactionType::Unvault as u32],
+        |row| {
+            let db_vault: DbVault = row.try_into()?;
+            let offset = 15;
+
+            // FIXME: there is probably a more extensible way to implement the from()s so we don't
+            // have to change all those when adding a column
+            let id: u32 = row.get(offset)?;
+            let psbt: Vec<u8> = row.get(offset + 1)?;
+            let psbt = UnvaultTransaction::from_psbt_serialized(&psbt).expect("We store it");
+            let is_fully_signed = row.get(offset + 2)?;
+            let db_tx = DbTransaction {
+                id,
+                vault_id: db_vault.id,
+                tx_type: TransactionType::Unvault,
+                psbt: RevaultTx::Unvault(psbt),
+                is_fully_signed,
+            };
+
+            Ok(db_tx)
+        },
+    )?
+    .pop())
+}
+
 /// Get a vault and its Unvault transaction out of an Unvault txid
 pub fn db_vault_by_unvault_txid(
     db_path: &Path,

src/jsonrpc/api.rs

@@ -214,6 +214,15 @@ pub trait RpcApi {
         end: u32,
         limit: u64,
     ) -> jsonrpc_core::Result<serde_json::Value>;
+
+    // Manually cpfp the given transaction id.
+    #[rpc(meta, name = "cpfp")]
+    fn cpfp(
+        &self,
+        meta: Self::Metadata,
+        txids: Vec<Txid>,
+        feerate: f64,
+    ) -> jsonrpc_core::Result<serde_json::Value>;
 }
 
 macro_rules! parse_vault_status {
@@ -301,6 +310,10 @@ impl RpcApi for RpcImpl {
             "emergency": [
 
             ],
+            "cpfp": [
+                "txids",
+                "feerate",
+            ],
         }))
     }
 
@@ -513,4 +526,16 @@ impl RpcApi for RpcImpl {
             "events": events,
         }))
     }
+
+    // manual CPFP command
+    // feerate will be in sat/vbyte
+    fn cpfp(
+        &self,
+        meta: Self::Metadata,
+        txids: Vec<Txid>,
+        feerate: f64,
+    ) -> jsonrpc_core::Result<serde_json::Value> {
+        meta.daemon_control.manual_cpfp(&txids, feerate)?;
+        Ok(json!({}))
+    }
 }

src/threadmessages.rs

@@ -41,6 +41,7 @@ pub enum BitcoindMessageOut {
         Vec<BitcoinTransaction>,
         SyncSender<Result<(), BitcoindError>>,
     ),
+    CPFPTransaction(Vec<Txid>, f64, SyncSender<Result<(), BitcoindError>>),
 }
 
 /// Interface to communicate with bitcoind client thread.
@@ -49,6 +50,7 @@ pub trait BitcoindThread {
     fn broadcast(&self, transactions: Vec<BitcoinTransaction>) -> Result<(), BitcoindError>;
     fn shutdown(&self);
     fn sync_progress(&self) -> f64;
+    fn cpfp_tx(&self, txids: Vec<Txid>, feerate: f64) -> Result<(), BitcoindError>;
 }
 
 /// Interface to the bitcoind thread using synchronous MPSCs
@@ -98,6 +100,18 @@ impl<'a> BitcoindThread for BitcoindSender {
 
         bitrep_rx.recv().expect("Receiving from bitcoind thread")
     }
+
+    fn cpfp_tx(&self, txids: Vec<Txid>, feerate: f64) -> Result<(), BitcoindError> {
+        let (bitrep_tx, bitrep_rx) = sync_channel(0);
+        self.0
+            .send(BitcoindMessageOut::CPFPTransaction(
+                txids, feerate, bitrep_tx,
+            ))
+            .expect("Sending to bitcoind thread");
+        bitrep_rx.recv().expect("Receiving from bitcoind thread")?;
+
+        Ok(())
+    }
 }
 
 impl From<Sender<BitcoindMessageOut>> for BitcoindSender {

src/utils.rs

@@ -178,5 +178,8 @@ addr = "127.0.0.1:8332"
         fn sync_progress(&self) -> f64 {
             1.0
         }
+        fn cpfp_tx(&self, _txid: Vec<Txid>, _feerate: f64) -> Result<(), BitcoindError> {
+            Ok(())
+        }
     }
 }