Addition of new RPC command along for manual cpfp.

Along with tests.

Author: Zshan0

src/bitcoind/mod.rs

@@ -3,9 +3,16 @@ pub mod poller;
 pub mod utils;
 
 use crate::config::BitcoindConfig;
-use crate::{database::DatabaseError, revaultd::RevaultD, threadmessages::BitcoindMessageOut};
+use crate::{
+    database::{
+        interface::{db_spend_transaction, db_vault_by_unvault_txid},
+        DatabaseError,
+    },
+    revaultd::RevaultD,
+    threadmessages::BitcoindMessageOut,
+};
 use interface::{BitcoinD, WalletTransaction};
-use poller::poller_main;
+use poller::{cpfp_package, poller_main, ToBeCpfped};
 use revault_tx::bitcoin::{Network, Txid};
 
 use std::{
@@ -187,6 +194,42 @@ fn wallet_transaction(bitcoind: &BitcoinD, txid: Txid) -> Option<WalletTransacti
         .ok()
 }
 
+fn cpfp(
+    revaultd: Arc<RwLock<RevaultD>>,
+    bitcoind: Arc<RwLock<BitcoinD>>,
+    txids: Vec<Txid>,
+    feerate: u64,
+) -> Result<(), BitcoindError> {
+    let db_path = revaultd.read().unwrap().db_file();
+    assert!(revaultd.read().unwrap().is_manager());
+
+    let mut cpfp_txs = Vec::with_capacity(txids.len());
+
+    for txid in txids.iter() {
+        log::debug!("[ZEE] looping over txids {}", txid);
+        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
+            log::debug!("[ZEE] spend_tx {:?}", unwrap_spend_tx);
+            cpfp_txs.push(ToBeCpfped::Spend(unwrap_spend_tx.psbt));
+        } else {
+            // If not SpendTransaction then it must be UnvaultTransaction
+            let unvault_tx = db_vault_by_unvault_txid(&db_path, &txid)
+                .expect("Database must be available")
+                .unwrap()
+                .1
+                .psbt
+                .unwrap_unvault()
+                .clone();
+            log::debug!("[ZEE] unvault_tx {:?}", unvault_tx);
+            cpfp_txs.push(ToBeCpfped::Unvault(unvault_tx));
+        }
+    }
+
+    cpfp_package(&revaultd, &bitcoind.read().unwrap(), cpfp_txs, feerate)
+}
+
 /// The bitcoind event loop.
 /// Listens for bitcoind requests (wallet / chain) and poll bitcoind every 30 seconds,
 /// updating our state accordingly.
@@ -208,7 +251,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 +296,18 @@ pub fn bitcoind_main_loop(
                         ))
                     })?;
             }
+            BitcoindMessageOut::CPFPTransaction(txids, feerate, resp_tx) => {
+                log::trace!("Received 'cpfptransaction' from main thread");
+                log::debug!("[ZEE] Received 'cpfptransaction' from main thread");
+
+                assert!(revaultd.read().unwrap().is_manager());
+                resp_tx
+                    .send(cpfp(revaultd, bitcoind, txids, feerate))
+                    .map_err(|e| {
+                        BitcoindError::Custom(format!("Sending transaction for CPFP: {}", e))
+                    })?;
+                return Ok(());
+            }
         }
     }
 

src/bitcoind/poller.rs

@@ -408,7 +408,8 @@ fn mark_confirmed_emers(
     Ok(())
 }
 
-enum ToBeCpfped {
+#[derive(Debug)]
+pub enum ToBeCpfped {
     Spend(SpendTransaction),
     Unvault(UnvaultTransaction),
 }
@@ -450,7 +451,7 @@ 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(
+pub fn cpfp_package(
     revaultd: &Arc<RwLock<RevaultD>>,
     bitcoind: &BitcoinD,
     to_be_cpfped: Vec<ToBeCpfped>,
@@ -459,6 +460,11 @@ fn cpfp_package(
     let revaultd = revaultd.read().unwrap();
     let cpfp_descriptor = &revaultd.cpfp_descriptor;
 
+    log::debug!(
+        "[ZEE] inside cpfp_package {:?} {:?}",
+        to_be_cpfped,
+        target_feerate
+    );
     // First of all, compute all the information we need from the to-be-cpfped transactions.
     let mut txids = HashSet::with_capacity(to_be_cpfped.len());
     let mut package_weight = 0;

src/commands/mod.rs

@@ -1421,6 +1421,24 @@ 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: u64) -> Result<(), CommandError> {
+        let revaultd = self.revaultd.read().unwrap();
+
+        if revaultd.cpfp_key.is_none() {
+            return Err(CommandError::MissingCpfpKey);
+        }
+        manager_only!(revaultd);
+
+        log::debug!("[ZEE] Triggering bitcoind_conn.cpfp_tx from main thread.");
+        self.bitcoind_conn.cpfp_tx(txids.to_vec(), feerate)?;
+        Ok(())
+    }
 }
 
 /// Descriptors the daemon was configured with

src/jsonrpc/api.rs

@@ -214,6 +214,23 @@ 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: u64,
+    ) -> jsonrpc_core::Result<serde_json::Value>;
+
+    #[rpc(meta, name = "ccpfp")]
+    fn ccpfp(
+        &self,
+        meta: Self::Metadata,
+        txids: Vec<Txid>,
+        feerate: u64,
+    ) -> jsonrpc_core::Result<serde_json::Value>;
 }
 
 macro_rules! parse_vault_status {
@@ -301,6 +318,10 @@ impl RpcApi for RpcImpl {
             "emergency": [
 
             ],
+            "cpfp": [
+                "txids",
+                "feerate",
+            ],
         }))
     }
 
@@ -513,4 +534,34 @@ impl RpcApi for RpcImpl {
             "events": events,
         }))
     }
+
+    // manual CPFP command
+    // feerate will be in satoshis [TODO API.md]
+    fn cpfp(
+        &self,
+        meta: Self::Metadata,
+        txids: Vec<Txid>,
+        feerate: u64,
+    ) -> jsonrpc_core::Result<serde_json::Value> {
+        log::debug!(
+            "[ZEE] Triggering manual_cpfp from jsonrpc/api.rs. {:?} {}",
+            txids,
+            feerate
+        );
+        meta.daemon_control.manual_cpfp(&txids, feerate)?;
+        Ok(json!({}))
+    }
+    fn ccpfp(
+        &self,
+        _: Self::Metadata,
+        txids: Vec<Txid>,
+        feerate: u64,
+    ) -> jsonrpc_core::Result<serde_json::Value> {
+        log::debug!(
+            "Triggering ccpfp from jsonrpc/api.rs. {:?} {}",
+            txids,
+            feerate
+        );
+        Ok(json!({}))
+    }
 }

src/threadmessages.rs

@@ -41,6 +41,7 @@ pub enum BitcoindMessageOut {
         Vec<BitcoinTransaction>,
         SyncSender<Result<(), BitcoindError>>,
     ),
+    CPFPTransaction(Vec<Txid>, u64, 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: u64) -> Result<(), BitcoindError>;
 }
 
 /// Interface to the bitcoind thread using synchronous MPSCs
@@ -98,6 +100,19 @@ impl<'a> BitcoindThread for BitcoindSender {
 
         bitrep_rx.recv().expect("Receiving from bitcoind thread")
     }
+
+    fn cpfp_tx(&self, txids: Vec<Txid>, feerate: u64) -> Result<(), BitcoindError> {
+        log::debug!("[ZEE] Sending 'cpfptransaction' from main thread");
+        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: u64) -> Result<(), BitcoindError> {
+            Ok(())
+        }
     }
 }

tests/servers/coordinatord

@@ -1348,3 +1348,68 @@ def test_gethistory(revault_network, bitcoind, executor):
             )
             == 5
         )
+
+
+COIN = 10**8
+
+
+def get_unvault_txids(wallet, vaults):
+    unvault_txids = []
+    for vault in vaults:
+        deposit = f"{vault['txid']}:{vault['vout']}"
+        unvault_psbt = serializations.PSBT()
+        unvault_b64 = wallet.rpc.listpresignedtransactions([deposit])[
+            "presigned_transactions"
+        ][0]["unvault"]
+        unvault_psbt.deserialize(unvault_b64)
+        unvault_psbt.tx.calc_sha256()
+        unvault_txids.append(unvault_psbt.tx.hash)
+    return unvault_txids
+
+
+@pytest.mark.skipif(not POSTGRES_IS_SETUP, reason="Needs Postgres for servers db")
+def test_manual_cpfp(revault_network, bitcoind):
+    CSV = 12
+    revault_network.deploy(
+        2,
+        1,
+        csv=CSV,
+        bitcoind_rpc_mocks={"estimatesmartfee": {"feerate": 0.0005}},  # 50 sats/vbyte
+    )
+    man = revault_network.mans()[0]
+    vaults = revault_network.fundmany([1, 2, 3])
+
+    # Broadcast the unvaults and get their txids
+    for vault in vaults:
+        revault_network.secure_vault(vault)
+        revault_network.activate_vault(vault)
+    spend_psbt = revault_network.broadcast_unvaults_anyhow(vaults, priority=True)
+    unvault_txids = get_unvault_txids(man, vaults)
+    spend_txid = spend_psbt.tx.hash
+    for w in revault_network.participants():
+        wait_for(
+            lambda: len(w.rpc.listvaults(["unvaulting"])["vaults"]) == len(vaults),
+        )
+
+    # If the feerate isn't significantly lower than the estimate, we won't feebump.
+    # Note the Unvault txs have a fixed 24sat/vb feerate.
+    entry = bitcoind.rpc.getmempoolentry(unvault_txids[0])
+    assert int(entry["fees"]["base"] * COIN / entry["vsize"]) == 24
+    revault_network.bitcoind_proxy.mocks["estimatesmartfee"] = {
+        "feerate": 26 * 1_000 / COIN
+    }
+    bitcoind.generate_blocks_censor(1, unvault_txids)
+    man.wait_for_logs(["Checking if transactions need CPFP...", "Nothing to CPFP"])
+
+    # Now if we set a high-enough target feerate, this'll trigger the CPFP.
+    revault_network.bitcoind_proxy.mocks["estimatesmartfee"] = {
+        "feerate": 50 * 1_000 / COIN
+    }
+    bitcoind.generate_blocks_censor(1, unvault_txids)
+    man.wait_for_log("CPFPed transactions")
+    wait_for(lambda: len(bitcoind.rpc.getrawmempool()) == len(unvault_txids) + 1)
+    for unvault_txid in unvault_txids:
+        entry = bitcoind.rpc.getmempoolentry(unvault_txid)
+        assert entry["descendantcount"] == 2
+        package_feerate = entry["fees"]["descendant"] * COIN / entry["descendantsize"]
+        assert package_feerate >= 50