Add populate_anchor_cache method to bdk

Author: +Sharon

crates/chain/src/tx_graph.rs

@@ -298,6 +298,13 @@ impl std::error::Error for CalculateFeeError {}
 impl<A> TxGraph<A> {
     /// Iterate over all tx outputs known by [`TxGraph`].
     ///
+    /// This returns an iterator over all anchors in the graph as (txid, anchor) pairs
+    pub fn anchors(&self) -> impl Iterator<Item = (Txid, &A)> + '_ {
+        self.anchors
+            .iter()
+            .flat_map(|(txid, anchors)| anchors.iter().map(move |a| (*txid, a)))
+    }
+
     /// This includes txouts of both full transactions as well as floating transactions.
     pub fn all_txouts(&self) -> impl Iterator<Item = (OutPoint, &TxOut)> {
         self.txs.iter().flat_map(|(txid, tx)| match tx {

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.
@@ -37,6 +38,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, ConfirmationBlockTime)>,
+    ) {
+        let mut cache = self.anchor_cache.lock().unwrap();
+        for (txid, anchor) in anchors {
+            cache.insert((txid, anchor.block_id.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

@@ -126,6 +126,16 @@ fn main() -> anyhow::Result<()> {
 
     let client = BdkElectrumClient::new(electrum_cmd.electrum_args().client(network)?);
 
+    // This avoids re-fetching known anchor confirmations from Electrum.
+    // Hold the lock for the entire anchor extraction
+    let graph_guard = graph.lock().unwrap();
+    // Collect anchors to release the lock quickly
+    let mut anchors = Vec::new();
+    for (txid, anchor) in graph_guard.graph().anchors() {
+        anchors.push((txid, *anchor)); // Dereference instead of clone for Copy types
+    }
+    client.populate_anchor_cache(anchors);
+
     // Tell the electrum client about the txs we've already got locally so it doesn't re-download
     // them
     client.populate_tx_cache(