deps: update bdk_chain to 4fe121e7

Author: ValuedMammal

examples/example_wallet_electrum/Cargo.toml

@@ -5,5 +5,6 @@ edition = "2021"
 
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
-bdk_electrum = { version = "0.21" }
+# bdk_electrum = { version = "0.21" }
+bdk_electrum = { git = "https://github.com/bitcoindevkit/bdk", rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc" }
 anyhow = "1"

examples/example_wallet_electrum/src/main.rs

@@ -22,7 +22,7 @@ const ELECTRUM_URL: &str = "ssl://electrum.blockstream.info:60002";
 fn main() -> Result<(), anyhow::Error> {
     let db_path = "bdk-electrum-example.db";
 
-    let mut db = Store::<bdk_wallet::ChangeSet>::open_or_create_new(DB_MAGIC.as_bytes(), db_path)?;
+    let (mut db, _) = Store::<bdk_wallet::ChangeSet>::load_or_create(DB_MAGIC.as_bytes(), db_path)?;
 
     let wallet_opt = Wallet::load()
         .descriptor(KeychainKind::External, Some(EXTERNAL_DESC))

examples/example_wallet_esplora_async/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["rusqlite"] }
-bdk_esplora = { version = "0.20", features = ["async-https", "tokio"] }
+# bdk_esplora = { version = "0.20", features = ["async-https", "tokio"] }
+bdk_esplora = { git = "https://github.com/bitcoindevkit/bdk", rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc", features = ["async-https", "tokio"] }
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }
 anyhow = "1"

examples/example_wallet_esplora_blocking/Cargo.toml

@@ -8,5 +8,6 @@ publish = false
 
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
-bdk_esplora = { version = "0.20", features = ["blocking"] }
+# bdk_esplora = { version = "0.20", features = ["blocking"] }
+bdk_esplora = { git = "https://github.com/bitcoindevkit/bdk", rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc", features = ["blocking"] }
 anyhow = "1"

examples/example_wallet_esplora_blocking/src/main.rs

@@ -19,7 +19,7 @@ const INTERNAL_DESC: &str = "wpkh(tprv8ZgxMBicQKsPdy6LMhUtFHAgpocR8GC6QmwMSFpZs7
 const ESPLORA_URL: &str = "http://signet.bitcoindevkit.net";
 
 fn main() -> Result<(), anyhow::Error> {
-    let mut db = Store::<bdk_wallet::ChangeSet>::open_or_create_new(DB_MAGIC.as_bytes(), DB_PATH)?;
+    let (mut db, _) = Store::<bdk_wallet::ChangeSet>::load_or_create(DB_MAGIC.as_bytes(), DB_PATH)?;
 
     let wallet_opt = Wallet::load()
         .descriptor(KeychainKind::External, Some(EXTERNAL_DESC))

examples/example_wallet_rpc/Cargo.toml

@@ -7,7 +7,8 @@ edition = "2021"
 
 [dependencies]
 bdk_wallet = { path = "../../wallet", features = ["file_store"] }
-bdk_bitcoind_rpc = { version = "0.18" }
+# bdk_bitcoind_rpc = { version = "0.18" }
+bdk_bitcoind_rpc = { git = "https://github.com/bitcoindevkit/bdk", rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc" }
 
 anyhow = "1"
 clap = { version = "4.5.17", features = ["derive", "env"] }

examples/example_wallet_rpc/src/main.rs

@@ -86,8 +86,8 @@ fn main() -> anyhow::Result<()> {
     );
 
     let start_load_wallet = Instant::now();
-    let mut db =
-        Store::<bdk_wallet::ChangeSet>::open_or_create_new(DB_MAGIC.as_bytes(), args.db_path)?;
+    let (mut db, _) =
+        Store::<bdk_wallet::ChangeSet>::load_or_create(DB_MAGIC.as_bytes(), args.db_path)?;
     let wallet_opt = Wallet::load()
         .descriptor(KeychainKind::External, Some(args.descriptor.clone()))
         .descriptor(KeychainKind::Internal, args.change_descriptor.clone())

wallet/Cargo.toml

@@ -21,11 +21,22 @@ miniscript = { version = "12.3.1", features = [ "serde" ], default-features = fa
 bitcoin = { version = "0.32.4", features = [ "serde", "base64" ], default-features = false }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
-bdk_chain = { version = "0.21.1", features = [ "miniscript", "serde" ], default-features = false }
-bdk_file_store = { version = "0.18.1", optional = true }
+# bdk_chain = { version = "0.22.0", features = [ "miniscript", "serde" ], default-features = false }
 
 # Optional dependencies
 bip39 = { version = "2.0", optional = true }
+# bdk_file_store = { version = "0.20.0", optional = true }
+
+[dependencies.bdk_chain]
+git = "https://github.com/bitcoindevkit/bdk"
+rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc"
+default-features = false
+features = ["miniscript", "serde"]
+
+[dependencies.bdk_file_store]
+git = "https://github.com/bitcoindevkit/bdk"
+rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc"
+optional = true
 
 [features]
 default = ["std"]
@@ -41,12 +52,16 @@ test-utils = ["std"]
 lazy_static = "1.4"
 assert_matches = "1.5.0"
 tempfile = "3"
-bdk_chain = { version = "0.21.1", features = ["rusqlite"] }
+# bdk_chain = { version = "0.22.0", features = ["rusqlite"] }
 bdk_wallet = { path = ".", features = ["rusqlite", "file_store", "test-utils"] }
-bdk_file_store = { version = "0.18.1" }
 anyhow = "1"
 rand = "^0.8"
 
+[dev-dependencies.bdk_chain]
+git = "https://github.com/bitcoindevkit/bdk"
+rev = "4fe121e7167cf93a8abf26c87d35b26a682f6cbc"
+features = ["rusqlite"]
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

wallet/README.md

@@ -65,13 +65,12 @@ To persist `Wallet` state data use a data store crate that reads and writes [`Ch
 
 **Example**
 
-<!-- compile_fail because outpoint and txout are fake variables -->
 ```rust,no_run
 use bdk_wallet::{bitcoin::Network, KeychainKind, ChangeSet, Wallet};
 
 // Open or create a new file store for wallet data.
-let mut db =
-    bdk_file_store::Store::<ChangeSet>::open_or_create_new(b"magic_bytes", "/tmp/my_wallet.db")
+let (mut db, _changeset) =
+    bdk_file_store::Store::<ChangeSet>::load_or_create(b"magic_bytes", "/tmp/my_wallet.db")
         .expect("create store");
 
 // Create a wallet with initial wallet data read from the file store.

wallet/src/test_utils.rs

@@ -4,7 +4,7 @@ use alloc::string::ToString;
 use alloc::sync::Arc;
 use core::str::FromStr;
 
-use bdk_chain::{tx_graph, BlockId, ConfirmationBlockTime};
+use bdk_chain::{BlockId, ConfirmationBlockTime, TxUpdate};
 use bitcoin::{
     absolute, hashes::Hash, transaction, Address, Amount, BlockHash, FeeRate, Network, OutPoint,
     Transaction, TxIn, TxOut, Txid,
@@ -312,43 +312,45 @@ pub fn insert_checkpoint(wallet: &mut Wallet, block: BlockId) {
         .unwrap();
 }
 
-/// Insert transaction
+/// Inserts a transaction into the local view, assuming it is currently present in the mempool.
+///
+/// This can be used, for example, to track a transaction immediately after it is broadcast.
 pub fn insert_tx(wallet: &mut Wallet, tx: Transaction) {
+    let txid = tx.compute_txid();
+    let seen_at = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
+    let mut tx_update = TxUpdate::default();
+    tx_update.txs = vec![Arc::new(tx)];
+    tx_update.seen_ats = [(txid, seen_at)].into();
     wallet
         .apply_update(Update {
-            tx_update: bdk_chain::TxUpdate {
-                txs: vec![Arc::new(tx)],
-                ..Default::default()
-            },
+            tx_update,
             ..Default::default()
         })
-        .unwrap();
+        .expect("failed to apply update");
 }
 
 /// Simulates confirming a tx with `txid` by applying an update to the wallet containing
 /// the given `anchor`. Note: to be considered confirmed the anchor block must exist in
 /// the current active chain.
 pub fn insert_anchor(wallet: &mut Wallet, txid: Txid, anchor: ConfirmationBlockTime) {
+    let mut tx_update = TxUpdate::default();
+    tx_update.anchors = [(anchor, txid)].into();
     wallet
         .apply_update(Update {
-            tx_update: tx_graph::TxUpdate {
-                anchors: [(anchor, txid)].into(),
-                ..Default::default()
-            },
+            tx_update,
             ..Default::default()
         })
-        .unwrap();
+        .expect("failed to apply update");
 }
 
 /// Marks the given `txid` seen as unconfirmed at `seen_at`
 pub fn insert_seen_at(wallet: &mut Wallet, txid: Txid, seen_at: u64) {
+    let mut tx_update = TxUpdate::default();
+    tx_update.seen_ats = [(txid, seen_at)].into();
     wallet
-        .apply_update(crate::Update {
-            tx_update: tx_graph::TxUpdate {
-                seen_ats: [(txid, seen_at)].into_iter().collect(),
-                ..Default::default()
-            },
+        .apply_update(Update {
+            tx_update,
             ..Default::default()
         })
-        .unwrap();
+        .expect("failed to apply update");
 }

wallet/src/wallet/mod.rs

@@ -2219,31 +2219,7 @@ impl Wallet {
     ///
     /// After applying updates you should persist the staged wallet changes. For an example of how
     /// to persist staged wallet changes see [`Wallet::reveal_next_address`].
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
     pub fn apply_update(&mut self, update: impl Into<Update>) -> Result<(), CannotConnectError> {
-        use std::time::*;
-        let now = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time now must surpass epoch anchor");
-        self.apply_update_at(update, now.as_secs())
-    }
-
-    /// Applies an `update` alongside a `seen_at` timestamp and stages the changes.
-    ///
-    /// `seen_at` represents when the update is seen (in unix seconds). It is used to determine the
-    /// `last_seen`s for all transactions in the update which have no corresponding anchor(s). The
-    /// `last_seen` value is used internally to determine precedence of conflicting unconfirmed
-    /// transactions (where the transaction with the lower `last_seen` value is omitted from the
-    /// canonical history).
-    ///
-    /// Use [`apply_update`](Wallet::apply_update) to have the `seen_at` value automatically set to
-    /// the current time.
-    pub fn apply_update_at(
-        &mut self,
-        update: impl Into<Update>,
-        seen_at: u64,
-    ) -> Result<(), CannotConnectError> {
         let update = update.into();
         let mut changeset = match update.chain {
             Some(chain_update) => ChangeSet::from(self.chain.apply_update(chain_update)?),
@@ -2255,11 +2231,7 @@ impl Wallet {
             .index
             .reveal_to_target_multi(&update.last_active_indices);
         changeset.merge(index_changeset.into());
-        changeset.merge(
-            self.indexed_graph
-                .apply_update_at(update.tx_update, Some(seen_at))
-                .into(),
-        );
+        changeset.merge(self.indexed_graph.apply_update(update.tx_update).into());
         self.stage.merge(changeset);
         Ok(())
     }
@@ -2397,16 +2369,47 @@ impl Wallet {
 
 /// Methods to construct sync/full-scan requests for spk-based chain sources.
 impl Wallet {
+    /// Create a partial [`SyncRequest`] for all revealed spks at `start_time`.
+    ///
+    /// The `start_time` is used to record the time that a mempool transaction was last seen
+    /// (or evicted). See [`Wallet::start_sync_with_revealed_spks`] for more.
+    pub fn start_sync_with_revealed_spks_at(
+        &self,
+        start_time: u64,
+    ) -> SyncRequestBuilder<(KeychainKind, u32)> {
+        use bdk_chain::keychain_txout::SyncRequestBuilderExt;
+        SyncRequest::builder_at(start_time)
+            .chain_tip(self.chain.tip())
+            .revealed_spks_from_indexer(&self.indexed_graph.index, ..)
+            .expected_spk_txids(self.indexed_graph.list_expected_spk_txids(
+                &self.chain,
+                self.chain.tip().block_id(),
+                ..,
+            ))
+    }
+
     /// Create a partial [`SyncRequest`] for this wallet for all revealed spks.
     ///
     /// This is the first step when performing a spk-based wallet partial sync, the returned
     /// [`SyncRequest`] collects all revealed script pubkeys from the wallet keychain needed to
     /// start a blockchain sync with a spk based blockchain client.
+    ///
+    /// The time of the sync is the current system time and is used to record the
+    /// tx last-seen for mempool transactions. Or if an expected transaction is missing
+    /// or evicted, it is the time of the eviction. Note that timestamps may only increase
+    /// to be counted by the tx graph. To supply your own start time see [`Wallet::start_sync_at`].
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    #[cfg(feature = "std")]
     pub fn start_sync_with_revealed_spks(&self) -> SyncRequestBuilder<(KeychainKind, u32)> {
         use bdk_chain::keychain_txout::SyncRequestBuilderExt;
         SyncRequest::builder()
             .chain_tip(self.chain.tip())
             .revealed_spks_from_indexer(&self.indexed_graph.index, ..)
+            .expected_spk_txids(self.indexed_graph.list_expected_spk_txids(
+                &self.chain,
+                self.chain.tip().block_id(),
+                ..,
+            ))
     }
 
     /// Create a [`FullScanRequest] for this wallet.
@@ -2417,12 +2420,22 @@ impl Wallet {
     ///
     /// This operation is generally only used when importing or restoring a previously used wallet
     /// in which the list of used scripts is not known.
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    #[cfg(feature = "std")]
     pub fn start_full_scan(&self) -> FullScanRequestBuilder<KeychainKind> {
         use bdk_chain::keychain_txout::FullScanRequestBuilderExt;
         FullScanRequest::builder()
             .chain_tip(self.chain.tip())
             .spks_from_indexer(&self.indexed_graph.index)
     }
+
+    /// Create a [`FullScanRequest`] builder at `start_time`.
+    pub fn start_full_scan_at(&self, start_time: u64) -> FullScanRequestBuilder<KeychainKind> {
+        use bdk_chain::keychain_txout::FullScanRequestBuilderExt;
+        FullScanRequest::builder_at(start_time)
+            .chain_tip(self.chain.tip())
+            .spks_from_indexer(&self.indexed_graph.index)
+    }
 }
 
 impl AsRef<bdk_chain::tx_graph::TxGraph<ConfirmationBlockTime>> for Wallet {

wallet/src/wallet/persisted.rs

@@ -291,7 +291,7 @@ impl WalletPersister for bdk_chain::rusqlite::Connection {
 #[derive(Debug)]
 pub enum FileStoreError {
     /// Error when loading from the store.
-    Load(bdk_file_store::AggregateChangesetsError<ChangeSet>),
+    Load(bdk_file_store::StoreErrorWithDump<ChangeSet>),
     /// Error when writing to the store.
     Write(std::io::Error),
 }
@@ -316,15 +316,13 @@ impl WalletPersister for bdk_file_store::Store<ChangeSet> {
 
     fn initialize(persister: &mut Self) -> Result<ChangeSet, Self::Error> {
         persister
-            .aggregate_changesets()
+            .dump()
             .map(Option::unwrap_or_default)
             .map_err(FileStoreError::Load)
     }
 
     fn persist(persister: &mut Self, changeset: &ChangeSet) -> Result<(), Self::Error> {
-        persister
-            .append_changeset(changeset)
-            .map_err(FileStoreError::Write)
+        persister.append(changeset).map_err(FileStoreError::Write)
     }
 }
 

wallet/tests/wallet.rs

@@ -117,8 +117,8 @@ fn wallet_is_persisted() -> anyhow::Result<()> {
 
     run(
         "store.db",
-        |path| Ok(bdk_file_store::Store::create_new(DB_MAGIC, path)?),
-        |path| Ok(bdk_file_store::Store::open(DB_MAGIC, path)?),
+        |path| Ok(bdk_file_store::Store::create(DB_MAGIC, path)?),
+        |path| Ok(bdk_file_store::Store::load(DB_MAGIC, path)?.0),
     )?;
     run::<bdk_chain::rusqlite::Connection, _, _>(
         "store.sqlite",
@@ -209,12 +209,8 @@ fn wallet_load_checks() -> anyhow::Result<()> {
 
     run(
         "store.db",
-        |path| {
-            Ok(bdk_file_store::Store::<ChangeSet>::create_new(
-                DB_MAGIC, path,
-            )?)
-        },
-        |path| Ok(bdk_file_store::Store::<ChangeSet>::open(DB_MAGIC, path)?),
+        |path| Ok(bdk_file_store::Store::<ChangeSet>::create(DB_MAGIC, path)?),
+        |path| Ok(bdk_file_store::Store::<ChangeSet>::load(DB_MAGIC, path)?.0),
     )?;
     run(
         "store.sqlite",