Add populate_anchor_cache method to bdk

Author: +Sharon

crates/electrum/src/bdk_electrum_client.rs

@@ -8,6 +8,8 @@ use bdk_core::{
 };
 use electrum_client::{ElectrumApi, Error, HeaderNotification};
 use std::sync::{Arc, Mutex};
+use std::convert::TryInto;
+
 
 /// We include a chain suffix of a certain length for the purpose of robustness.
 const CHAIN_SUFFIX_LENGTH: u32 = 8;
@@ -37,6 +39,18 @@ impl<E: ElectrumApi> BdkElectrumClient<E> {
         }
     }
 
+    /// Insert anchors into the anchor cache so that they don’t have to be fetched again from Electrum.
+    /// Typically used to pre-populate the cache from an existing `TxGraph`.
+    pub fn populate_anchor_cache(
+        &self,
+        anchors: impl IntoIterator<Item = ((Txid, BlockHash), ConfirmationBlockTime)>,
+    ) {
+        let mut cache = self.anchor_cache.lock().unwrap();
+        for ((txid, block_hash), anchor) in anchors {
+            cache.insert((txid, block_hash), anchor);
+        }
+    }
+
     /// Inserts transactions into the transaction cache so that the client will not fetch these
     /// transactions.
     pub fn populate_tx_cache(&self, txs: impl IntoIterator<Item = impl Into<Arc<Transaction>>>) {

examples/example_electrum/src/main.rs

@@ -1,9 +1,10 @@
 use std::io::{self, Write};
 
 use bdk_chain::{
-    bitcoin::Network,
+    bitcoin::{Network,Txid, BlockHash},
     collections::BTreeSet,
     indexed_tx_graph,
+    TxGraph,
     spk_client::{FullScanRequest, SyncRequest},
     CanonicalizationParams, ConfirmationBlockTime, Merge,
 };
@@ -94,6 +95,28 @@ pub struct ScanOptions {
     pub batch_size: usize,
 }
 
+/// Extension trait to expose anchors in a public-friendly way
+trait TxGraphExt {
+    fn iter_anchors_ext(
+        &self,
+    ) -> Box<dyn Iterator<Item = ((Txid, BlockHash), ConfirmationBlockTime)> + '_>;
+}
+
+impl TxGraphExt for TxGraph<ConfirmationBlockTime> {
+    fn iter_anchors_ext(
+        &self,
+    ) -> Box<dyn Iterator<Item = ((Txid, BlockHash), ConfirmationBlockTime)> + '_> {
+        Box::new(
+            self.full_txs().flat_map(move |tx_node| {
+                tx_node.anchors.iter().map(move |anchor| {
+                    let block_id = anchor.block_id;
+                    ((tx_node.txid, block_id.hash), anchor.clone())
+                })
+            }),
+        )
+    }
+}
+
 fn main() -> anyhow::Result<()> {
     let example_cli::Init {
         args,
@@ -125,6 +148,13 @@ fn main() -> anyhow::Result<()> {
     };
 
     let client = BdkElectrumClient::new(electrum_cmd.electrum_args().client(network)?);
+    
+    // Lock the graph so we can safely borrow data from it,
+    // and extract all anchor data in a public-friendly format using the extension trait.
+    // This avoids re-fetching known anchor confirmations from Electrum.
+    let g = graph.lock().unwrap();
+    let anchors = g.graph().iter_anchors_ext();
+    client.populate_anchor_cache(anchors);
 
     // Tell the electrum client about the txs we've already got locally so it doesn't re-download
     // them