feat: add utilities for testing persistence

Added `persist_wallet_changeset` function and supporting functions.

Author: 110CodingP

wallet/Cargo.toml

@@ -22,6 +22,9 @@ bitcoin = { version = "0.32.6", features = [ "serde", "base64" ], default-featur
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 bdk_chain = { version = "0.23.0", features = [ "miniscript", "serde" ], default-features = false }
+anyhow = { version = "1.0.98", optional = true }
+tempfile = { version = "3.20.0", optional = true }
+bdk_testenv = { version = "0.13.0", optional = true}
 
 # Optional dependencies
 bip39 = { version = "2.0", optional = true }
@@ -35,7 +38,7 @@ all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
 rusqlite = ["bdk_chain/rusqlite"]
 file_store = ["bdk_file_store"]
-test-utils = ["std"]
+test-utils = ["std", "anyhow", "tempfile", "bdk_testenv"]
 
 [dev-dependencies]
 assert_matches = "1.5.0"

wallet/src/lib.rs

@@ -31,6 +31,10 @@ pub mod keys;
 pub mod psbt;
 #[cfg(feature = "test-utils")]
 pub mod test_utils;
+
+#[cfg(feature = "test-utils")]
+pub mod persist_test_utils;
+
 mod types;
 mod wallet;
 

wallet/src/persist_test_utils.rs

@@ -0,0 +1,171 @@
+use crate::{
+    bitcoin::{
+        absolute, hashes::Hash, transaction, Amount, BlockHash, Network, OutPoint, ScriptBuf,
+        Transaction, TxIn, TxOut, Txid,
+    },
+    chain::{keychain_txout, local_chain, tx_graph, ConfirmationBlockTime, DescriptorExt, Merge},
+    miniscript::descriptor::{Descriptor, DescriptorPublicKey},
+    ChangeSet, WalletPersister,
+};
+use std::collections::BTreeMap;
+use std::fmt::Debug;
+use std::path::Path;
+use std::sync::Arc;
+use bdk_testenv::{block_id, hash};
+
+pub const DESCRIPTORS: [&str; 4] = [
+    "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/1/*)#ypcpw2dr",
+    "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/0/*)#44aqnlam",
+    "wpkh([41f2aed0/84h/1h/0h]tpubDDFSdQWw75hk1ewbwnNpPp5DvXFRKt68ioPoyJDY752cNHKkFxPWqkqCyCf4hxrEfpuxh46QisehL3m8Bi6MsAv394QVLopwbtfvryFQNUH/1/*)#emtwewtk",
+    "wpkh([41f2aed0/84h/1h/0h]tpubDDFSdQWw75hk1ewbwnNpPp5DvXFRKt68ioPoyJDY752cNHKkFxPWqkqCyCf4hxrEfpuxh46QisehL3m8Bi6MsAv394QVLopwbtfvryFQNUH/0/*)#g0w0ymmw",
+];
+
+pub fn create_one_inp_one_out_tx(txid: Txid, amount: u64) -> Transaction {
+    Transaction {
+        version: transaction::Version::ONE,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![TxIn {
+            previous_output: OutPoint::new(txid, 0),
+            ..TxIn::default()
+        }],
+        output: vec![TxOut {
+            value: Amount::from_sat(amount),
+            script_pubkey: ScriptBuf::new(),
+        }],
+    }
+}
+
+pub fn run<Db, CreateDb>(filename: &str, create_db: CreateDb)
+where
+    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
+    Db: WalletPersister,
+    Db::Error: Debug,
+{
+    let temp_dir = tempfile::tempdir().expect("must create tempdir");
+    let file_path = temp_dir.path().join(filename);
+
+    let mut db = create_db(&file_path).expect("db should get created");
+
+    let changeset =
+        WalletPersister::initialize(&mut db).expect("empty changeset should get loaded");
+    assert_eq!(changeset, ChangeSet::default());
+
+    let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[0].parse().unwrap();
+    let change_descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
+
+    let mut blocks: BTreeMap<u32, Option<BlockHash>> = BTreeMap::new();
+    blocks.insert(0u32, Some(hash!("B")));
+    blocks.insert(1u32, Some(hash!("T")));
+    blocks.insert(2u32, Some(hash!("C")));
+    let local_chain_changeset = local_chain::ChangeSet { blocks };
+
+    let tx1 = Arc::new(create_one_inp_one_out_tx(
+        Txid::from_byte_array([0; 32]),
+        30_000,
+    ));
+    let tx2 = Arc::new(create_one_inp_one_out_tx(tx1.compute_txid(), 20_000));
+
+    let block_id = block_id!(1, "BDK");
+
+    let conf_anchor: ConfirmationBlockTime = ConfirmationBlockTime {
+        block_id,
+        confirmation_time: 123,
+    };
+
+    let tx_graph_changeset = tx_graph::ChangeSet::<ConfirmationBlockTime> {
+        txs: [tx1.clone()].into(),
+        txouts: [].into(),
+        anchors: [(conf_anchor, tx1.compute_txid())].into(),
+        last_seen: [(tx1.compute_txid(), 100)].into(),
+        first_seen: [(tx1.compute_txid(), 80)].into(),
+        last_evicted: [(tx1.compute_txid(), 150)].into(),
+    };
+
+    let keychain_txout_changeset = keychain_txout::ChangeSet {
+        last_revealed: [
+            (descriptor.descriptor_id(), 12),
+            (change_descriptor.descriptor_id(), 10),
+        ]
+        .into(),
+        spk_cache: [
+            (
+                descriptor.descriptor_id(),
+                [(0u32, ScriptBuf::from_bytes(vec![245, 123, 112]))].into(),
+            ),
+            (
+                change_descriptor.descriptor_id(),
+                [
+                    (100u32, ScriptBuf::from_bytes(vec![145, 234, 98])),
+                    (1000u32, ScriptBuf::from_bytes(vec![5, 6, 8])),
+                ]
+                .into(),
+            ),
+        ]
+        .into(),
+    };
+
+    let mut changeset = ChangeSet {
+        descriptor: Some(descriptor.clone()),
+        change_descriptor: Some(change_descriptor.clone()),
+        network: Some(Network::Bitcoin),
+        local_chain: local_chain_changeset,
+        tx_graph: tx_graph_changeset,
+        indexer: keychain_txout_changeset,
+    };
+
+    WalletPersister::persist(&mut db, &changeset).expect("changeset should get persisted");
+
+    let changeset_read = WalletPersister::initialize(&mut db).expect("changeset should get loaded");
+
+    assert_eq!(changeset, changeset_read);
+
+    let mut blocks: BTreeMap<u32, Option<BlockHash>> = BTreeMap::new();
+    blocks.insert(4u32, Some(hash!("RE")));
+    blocks.insert(5u32, Some(hash!("DB")));
+    let local_chain_changeset = local_chain::ChangeSet { blocks };
+
+    let block_id = block_id!(2, "Bitcoin");
+
+    let conf_anchor: ConfirmationBlockTime = ConfirmationBlockTime {
+        block_id,
+        confirmation_time: 214,
+    };
+
+    let tx_graph_changeset = tx_graph::ChangeSet::<ConfirmationBlockTime> {
+        txs: [tx2.clone()].into(),
+        txouts: [].into(),
+        anchors: [(conf_anchor, tx2.compute_txid())].into(),
+        last_seen: [(tx2.compute_txid(), 200)].into(),
+        first_seen: [(tx2.compute_txid(), 160)].into(),
+        last_evicted: [(tx2.compute_txid(), 300)].into(),
+    };
+
+    let keychain_txout_changeset = keychain_txout::ChangeSet {
+        last_revealed: [(descriptor.descriptor_id(), 14)].into(),
+        spk_cache: [(
+            change_descriptor.descriptor_id(),
+            [
+                (102u32, ScriptBuf::from_bytes(vec![8, 45, 78])),
+                (1001u32, ScriptBuf::from_bytes(vec![29, 56, 47])),
+            ]
+            .into(),
+        )]
+        .into(),
+    };
+
+    let changeset_new = ChangeSet {
+        descriptor: Some(descriptor),
+        change_descriptor: Some(change_descriptor),
+        network: Some(Network::Bitcoin),
+        local_chain: local_chain_changeset,
+        tx_graph: tx_graph_changeset,
+        indexer: keychain_txout_changeset,
+    };
+
+    WalletPersister::persist(&mut db, &changeset_new).expect("changeset should get persisted");
+    let changeset_read_new = WalletPersister::initialize(&mut db).unwrap();
+
+    changeset.merge(changeset_new);
+
+    assert_eq!(changeset, changeset_read_new);
+}