Merge branch 'master' into kwsantiago/1973-simplify-examples

Author: kwsantiago

ci/pin-msrv.sh

@@ -31,3 +31,4 @@ cargo update -p tracing-core --precise "0.1.33"
 cargo update -p [email protected] --precise "1.0.1"
 cargo update -p rayon --precise "1.10.0"
 cargo update -p rayon-core --precise "1.12.1"
+cargo update -p [email protected] --precise "0.5.10"

crates/electrum/src/bdk_electrum_client.rs

@@ -7,6 +7,7 @@ use bdk_core::{
     BlockId, CheckPoint, ConfirmationBlockTime, TxUpdate,
 };
 use electrum_client::{ElectrumApi, Error, HeaderNotification};
+use std::convert::TryInto;
 use std::sync::{Arc, Mutex};
 
 /// We include a chain suffix of a certain length for the purpose of robustness.
@@ -46,8 +47,24 @@ impl<E: ElectrumApi> BdkElectrumClient<E> {
         }
     }
 
-    /// Inserts transactions into the transaction cache so that the client will not fetch these
-    /// transactions.
+    /// Insert anchors into the anchor cache so that the client will not re-fetch them.
+    ///
+    /// Typically used to pre-populate the cache from an existing `TxGraph`.
+    pub fn populate_anchor_cache(
+        &self,
+        tx_anchors: impl IntoIterator<Item = (Txid, impl IntoIterator<Item = ConfirmationBlockTime>)>,
+    ) {
+        let mut cache = self.anchor_cache.lock().unwrap();
+        for (txid, anchors) in tx_anchors {
+            for anchor in anchors {
+                cache.insert((txid, anchor.block_id.hash), anchor);
+            }
+        }
+    }
+
+    /// Insert transactions into the transaction cache so that the client will not re-fetch them.
+    ///
+    /// Typically used to pre-populate the cache from an existing `TxGraph`.
     pub fn populate_tx_cache(&self, txs: impl IntoIterator<Item = impl Into<Arc<Transaction>>>) {
         let mut tx_cache = self.tx_cache.lock().unwrap();
         for tx in txs {
@@ -547,17 +564,16 @@ impl<E: ElectrumApi> BdkElectrumClient<E> {
                 if let Some(anchor) = anchor_cache.get(&(txid, hash)) {
                     results.push((txid, *anchor));
                 } else {
-                    to_fetch.push((txid, height, hash));
+                    to_fetch.push((txid, height));
                 }
             }
         }
 
         // Fetch merkle proofs.
-        let txids_and_heights = to_fetch.iter().map(|&(txid, height, _)| (txid, height));
-        let proofs = self.inner.batch_transaction_get_merkle(txids_and_heights)?;
+        let proofs = self.inner.batch_transaction_get_merkle(to_fetch.iter())?;
 
         // Validate each proof, retrying once for each stale header.
-        for ((txid, height, hash), proof) in to_fetch.into_iter().zip(proofs.into_iter()) {
+        for ((txid, height), proof) in to_fetch.into_iter().zip(proofs.into_iter()) {
             let mut header = {
                 let cache = self.block_header_cache.lock().unwrap();
                 cache
@@ -582,6 +598,7 @@ impl<E: ElectrumApi> BdkElectrumClient<E> {
 
             // Build and cache the anchor if merkle proof is valid.
             if valid {
+                let hash = header.block_hash();
                 let anchor = ConfirmationBlockTime {
                     confirmation_time: header.time as u64,
                     block_id: BlockId {
@@ -725,11 +742,13 @@ fn chain_update(
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod test {
-    use crate::{bdk_electrum_client::TxUpdate, BdkElectrumClient};
+    use crate::{bdk_electrum_client::TxUpdate, electrum_client::ElectrumApi, BdkElectrumClient};
+    use bdk_chain::bitcoin::Amount;
     use bdk_chain::bitcoin::{constants, Network, OutPoint, ScriptBuf, Transaction, TxIn};
     use bdk_chain::{BlockId, CheckPoint};
     use bdk_core::{collections::BTreeMap, spk_client::SyncRequest};
-    use bdk_testenv::{anyhow, utils::new_tx, TestEnv};
+    use bdk_testenv::{anyhow, bitcoincore_rpc::RpcApi, utils::new_tx, TestEnv};
+    use core::time::Duration;
     use electrum_client::Error as ElectrumError;
     use std::sync::Arc;
 
@@ -793,4 +812,66 @@ mod test {
 
         Ok(())
     }
+
+    /// This test checks that when a transaction is reorged into a different block
+    /// at the same height, `batch_fetch_anchors()` updates its anchor correctly:
+    ///
+    /// 1. A transaction is confirmed in a block, and that block header is cached.
+    /// 2. A reorg happens, replacing that block with a new one at the same height.
+    /// 3. When we call `batch_fetch_anchors()`, it should fetch the new block header and recreate
+    ///    the transaction’s anchor using the new block hash.
+    ///
+    /// Reorgs should cause the anchor to point to the new block instead of the stale one.
+    #[cfg(feature = "default")]
+    #[test]
+    fn test_batch_fetch_anchors_reorg_uses_new_hash() -> anyhow::Result<()> {
+        let env = TestEnv::new()?;
+        let client = electrum_client::Client::new(env.electrsd.electrum_url.as_str()).unwrap();
+        let electrum_client = BdkElectrumClient::new(client);
+
+        env.mine_blocks(101, None)?;
+
+        let addr = env
+            .rpc_client()
+            .get_new_address(None, None)?
+            .assume_checked();
+        let txid = env.send(&addr, Amount::from_sat(50_000))?;
+
+        // Mine block that confirms transaction.
+        env.mine_blocks(1, None)?;
+        env.wait_until_electrum_sees_block(Duration::from_secs(6))?;
+        let height: u32 = env.rpc_client().get_block_count()? as u32;
+
+        // Add the pre-reorg block that the tx is confirmed in to the header cache.
+        let header = electrum_client.inner.block_header(height as usize)?;
+        {
+            electrum_client
+                .block_header_cache
+                .lock()
+                .unwrap()
+                .insert(height, header);
+        }
+
+        // Reorg to create a new header and hash.
+        env.reorg(1)?;
+        env.wait_until_electrum_sees_block(Duration::from_secs(6))?;
+
+        // Calling `batch_fetch_anchors` should fetch new header, replacing the pre-reorg header.
+        let anchors = electrum_client.batch_fetch_anchors(&[(txid, height as usize)])?;
+        assert_eq!(anchors.len(), 1);
+
+        let new_header = electrum_client.inner.block_header(height as usize)?;
+        let new_hash = new_header.block_hash();
+
+        // Anchor should contain new hash.
+        let (_, anchor) = anchors[0];
+        assert_eq!(anchor.block_id.height, height);
+        assert_eq!(anchor.block_id.hash, new_hash);
+
+        // Anchor cache should also contain new hash.
+        let cache = electrum_client.anchor_cache.lock().unwrap();
+        assert!(cache.get(&(txid, new_hash)).is_some());
+
+        Ok(())
+    }
 }