fix: persistence tests

110CodingP · 110CodingP · commit 5df03f7939c3 · 2025-08-12T16:49:57.000+05:30
diff --git a/wallet/src/persist_test_utils.rs b/wallet/src/persist_test_utils.rs
@@ -1,8 +1,8 @@
 #![allow(missing_docs)]
 use crate::{
     bitcoin::{
-        absolute, hashes::Hash, transaction, Amount, BlockHash, Network, OutPoint, ScriptBuf,
-        Transaction, TxIn, TxOut, Txid,
+        absolute, hashes::Hash, key::Secp256k1, transaction, Address, Amount, BlockHash, Network,
+        OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid,
     },
     chain::{keychain_txout, local_chain, tx_graph, ConfirmationBlockTime, DescriptorExt, Merge},
     miniscript::descriptor::{Descriptor, DescriptorPublicKey},
@@ -12,13 +12,14 @@ use bdk_testenv::{block_id, hash};
 use std::collections::BTreeMap;
 use std::fmt::Debug;
 use std::path::Path;
+use std::str::FromStr;
 use std::sync::Arc;
 
-pub const DESCRIPTORS: [&str; 4] = [
-    "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/1/*)#ypcpw2dr",
+const DESCRIPTORS: [&str; 4] = [
     "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/0/*)#44aqnlam",
-    "wpkh([41f2aed0/84h/1h/0h]tpubDDFSdQWw75hk1ewbwnNpPp5DvXFRKt68ioPoyJDY752cNHKkFxPWqkqCyCf4hxrEfpuxh46QisehL3m8Bi6MsAv394QVLopwbtfvryFQNUH/1/*)#emtwewtk",
+    "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/1/*)#ypcpw2dr",
     "wpkh([41f2aed0/84h/1h/0h]tpubDDFSdQWw75hk1ewbwnNpPp5DvXFRKt68ioPoyJDY752cNHKkFxPWqkqCyCf4hxrEfpuxh46QisehL3m8Bi6MsAv394QVLopwbtfvryFQNUH/0/*)#g0w0ymmw",
+    "wpkh([41f2aed0/84h/1h/0h]tpubDDFSdQWw75hk1ewbwnNpPp5DvXFRKt68ioPoyJDY752cNHKkFxPWqkqCyCf4hxrEfpuxh46QisehL3m8Bi6MsAv394QVLopwbtfvryFQNUH/1/*)#emtwewtk",
 ];
 
 pub fn create_one_inp_one_out_tx(txid: Txid, amount: u64) -> Transaction {
@@ -31,33 +32,49 @@ pub fn create_one_inp_one_out_tx(txid: Txid, amount: u64) -> Transaction {
         }],
         output: vec![TxOut {
             value: Amount::from_sat(amount),
-            script_pubkey: ScriptBuf::new(),
+            script_pubkey: Address::from_str("bcrt1q3qtze4ys45tgdvguj66zrk4fu6hq3a3v9pfly5")
+                .unwrap()
+                .assume_checked()
+                .script_pubkey(),
         }],
     }
 }
 
-pub fn persist_wallet_changeset<Db, CreateDb>(filename: &str, create_db: CreateDb)
+fn spk_at_index(descriptor: &Descriptor<DescriptorPublicKey>, index: u32) -> ScriptBuf {
+    descriptor
+        .derived_descriptor(&Secp256k1::verification_only(), index)
+        .expect("must derive")
+        .script_pubkey()
+}
+
+pub fn create_test_store<Store, CreateStore>(filename: &str, create_store: CreateStore) -> Store
 where
-    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
-    Db: WalletPersister,
-    Db::Error: Debug,
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
 {
     let temp_dir = tempfile::tempdir().expect("must create tempdir");
     let file_path = temp_dir.path().join(filename);
+    create_store(&file_path).expect("store should get created")
+}
 
-    let mut db = create_db(&file_path).expect("db should get created");
+pub fn persist_wallet_changeset<Store, CreateStore>(filename: &str, create_store: CreateStore)
+where
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
+    Store: WalletPersister,
+    Store::Error: Debug,
+{
+    let mut store = create_test_store(filename, create_store);
 
     let changeset =
-        WalletPersister::initialize(&mut db).expect("empty changeset should get loaded");
+        WalletPersister::initialize(&mut store).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")));
+    blocks.insert(1u32, Some(hash!("B")));
+    blocks.insert(2u32, Some(hash!("T")));
+    blocks.insert(3u32, Some(hash!("C")));
     let local_chain_changeset = local_chain::ChangeSet { blocks };
 
     let tx1 = Arc::new(create_one_inp_one_out_tx(
@@ -75,7 +92,23 @@ where
 
     let tx_graph_changeset = tx_graph::ChangeSet::<ConfirmationBlockTime> {
         txs: [tx1.clone()].into(),
-        txouts: [].into(),
+        txouts: [
+            (
+                OutPoint::new(Txid::from_byte_array([0; 32]), 0),
+                TxOut {
+                    value: Amount::from_sat(1300),
+                    script_pubkey: spk_at_index(&descriptor, 4),
+                },
+            ),
+            (
+                OutPoint::new(Txid::from_byte_array([1; 32]), 0),
+                TxOut {
+                    value: Amount::from_sat(1400),
+                    script_pubkey: spk_at_index(&descriptor, 10)
+                },
+            ),
+        ]
+        .into(),
         anchors: [(conf_anchor, tx1.compute_txid())].into(),
         last_seen: [(tx1.compute_txid(), 100)].into(),
         first_seen: [(tx1.compute_txid(), 80)].into(),
@@ -91,13 +124,13 @@ where
         spk_cache: [
             (
                 descriptor.descriptor_id(),
-                [(0u32, ScriptBuf::from_bytes(vec![245, 123, 112]))].into(),
+                [(0u32, spk_at_index(&descriptor, 0))].into(),
             ),
             (
                 change_descriptor.descriptor_id(),
                 [
-                    (100u32, ScriptBuf::from_bytes(vec![145, 234, 98])),
-                    (1000u32, ScriptBuf::from_bytes(vec![5, 6, 8])),
+                    (100u32, spk_at_index(&change_descriptor, 100)),
+                    (1000u32, spk_at_index(&change_descriptor, 1000)),
                 ]
                 .into(),
             ),
@@ -114,9 +147,10 @@ where
         indexer: keychain_txout_changeset,
     };
 
-    WalletPersister::persist(&mut db, &changeset).expect("changeset should get persisted");
+    WalletPersister::persist(&mut store, &changeset).expect("changeset should get persisted");
 
-    let changeset_read = WalletPersister::initialize(&mut db).expect("changeset should get loaded");
+    let changeset_read =
+        WalletPersister::initialize(&mut store).expect("changeset should get loaded");
 
     assert_eq!(changeset, changeset_read);
 
@@ -134,7 +168,14 @@ where
 
     let tx_graph_changeset = tx_graph::ChangeSet::<ConfirmationBlockTime> {
         txs: [tx2.clone()].into(),
-        txouts: [].into(),
+        txouts: [(
+            OutPoint::new(Txid::from_byte_array([2; 32]), 0),
+            TxOut {
+                value: Amount::from_sat(10000),
+                script_pubkey: spk_at_index(&descriptor, 21),
+            },
+        )]
+        .into(),
         anchors: [(conf_anchor, tx2.compute_txid())].into(),
         last_seen: [(tx2.compute_txid(), 200)].into(),
         first_seen: [(tx2.compute_txid(), 160)].into(),
@@ -146,30 +187,31 @@ where
         spk_cache: [(
             change_descriptor.descriptor_id(),
             [
-                (102u32, ScriptBuf::from_bytes(vec![8, 45, 78])),
-                (1001u32, ScriptBuf::from_bytes(vec![29, 56, 47])),
+                (102u32, spk_at_index(&change_descriptor, 102)),
+                (1001u32, spk_at_index(&change_descriptor, 1001)),
             ]
             .into(),
         )]
         .into(),
     };
 
     let changeset_new = ChangeSet {
-        descriptor: Some(descriptor),
-        change_descriptor: Some(change_descriptor),
-        network: Some(Network::Bitcoin),
+        descriptor: None,
+        change_descriptor: None,
+        network: None,
         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();
+    WalletPersister::persist(&mut store, &changeset_new).expect("changeset should get persisted");
+    let changeset_read_new = WalletPersister::initialize(&mut store).unwrap();
 
     changeset.merge(changeset_new);
 
     assert_eq!(changeset, changeset_read_new);
 }
+
 pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
     filename: &str,
     create_dbs: CreateStores,
@@ -184,6 +226,10 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
     let (mut store_first, mut store_sec) =
         create_dbs(&file_path).expect("store should get created");
 
+    let changeset =
+        WalletPersister::initialize(&mut store_first).expect("should load empty changeset");
+    assert_eq!(changeset, ChangeSet::default());
+
     let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[0].parse().unwrap();
     let change_descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
 
@@ -194,10 +240,6 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
         ..ChangeSet::default()
     };
 
-    let changeset =
-        WalletPersister::initialize(&mut store_first).expect("should load empty changeset");
-    assert_eq!(changeset, ChangeSet::default());
-
     WalletPersister::persist(&mut store_first, &changeset1).expect("should persist changeset");
 
     let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[2].parse().unwrap();
@@ -225,84 +267,79 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
     assert_eq!(changeset_read, changeset2);
 }
 
-pub fn persist_network<Db, CreateDb>(filename: &str, create_db: CreateDb)
+pub fn persist_network<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
-    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
-    Db: WalletPersister,
-    Db::Error: Debug,
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
+    Store: WalletPersister,
+    Store::Error: Debug,
 {
     // create db
-    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 mut store = create_test_store(filename, create_store);
 
     // initialize db
-    let changeset =
-        WalletPersister::initialize(&mut db).expect("should initialize and load empty changeset");
+    let changeset = WalletPersister::initialize(&mut store)
+        .expect("should initialize and load empty changeset");
     assert_eq!(changeset, ChangeSet::default());
 
     // persist the network
     let changeset = ChangeSet {
         network: Some(Network::Bitcoin),
         ..ChangeSet::default()
     };
-    WalletPersister::persist(&mut db, &changeset).expect("should persist changeset");
+    WalletPersister::persist(&mut store, &changeset).expect("should persist changeset");
 
     // read the persisted changeset
     let changeset_read =
-        WalletPersister::initialize(&mut db).expect("should load persisted changeset");
+        WalletPersister::initialize(&mut store).expect("should load persisted changeset");
 
     assert_eq!(changeset_read.network, Some(Network::Bitcoin));
 }
 
-pub fn persist_keychains<Db, CreateDb>(filename: &str, create_db: CreateDb)
+// this is technically incorrect but helps in catching errors in impl which the first one doesn't
+pub fn persist_keychains<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
-    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
-    Db: WalletPersister,
-    Db::Error: Debug,
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
+    Store: WalletPersister,
+    Store::Error: Debug,
 {
     // create db
-    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 mut store = create_test_store(filename, create_store);
 
     // initialize db
-    let changeset =
-        WalletPersister::initialize(&mut db).expect("should initialize and load empty changeset");
+    let changeset = WalletPersister::initialize(&mut store)
+        .expect("should initialize and load empty changeset");
     assert_eq!(changeset, ChangeSet::default());
 
-    let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[0].parse().unwrap();
-    let change_descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
+    let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
+    let change_descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[0].parse().unwrap();
 
     let changeset = ChangeSet {
         descriptor: Some(descriptor.clone()),
         change_descriptor: Some(change_descriptor.clone()),
         ..ChangeSet::default()
     };
 
-    WalletPersister::persist(&mut db, &changeset).expect("should persist descriptors");
+    WalletPersister::persist(&mut store, &changeset).expect("should persist descriptors");
 
     let changeset_read =
-        WalletPersister::initialize(&mut db).expect("should read persisted changeset");
+        WalletPersister::initialize(&mut store).expect("should read persisted changeset");
 
     assert_eq!(changeset_read.descriptor.unwrap(), descriptor);
     assert_eq!(changeset_read.change_descriptor.unwrap(), change_descriptor);
 }
 
-pub fn persist_keychains_reversed<Db, CreateDb>(filename: &str, create_db: CreateDb)
+pub fn persist_keychains_reversed<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
-    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
-    Db: WalletPersister,
-    Db::Error: Debug,
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
+    Store: WalletPersister,
+    Store::Error: Debug,
 {
     // create db
-    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 mut store = create_test_store(filename, create_store);
 
     // initialize db
-    let changeset =
-        WalletPersister::initialize(&mut db).expect("should initialize and load empty changeset");
+    let changeset = WalletPersister::initialize(&mut store)
+        .expect("should initialize and load empty changeset");
     assert_eq!(changeset, ChangeSet::default());
 
     let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
@@ -314,42 +351,40 @@ where
         ..ChangeSet::default()
     };
 
-    WalletPersister::persist(&mut db, &changeset).expect("should persist descriptors");
+    WalletPersister::persist(&mut store, &changeset).expect("should persist descriptors");
 
     let changeset_read =
-        WalletPersister::initialize(&mut db).expect("should read persisted changeset");
+        WalletPersister::initialize(&mut store).expect("should read persisted changeset");
 
     assert_eq!(changeset_read.descriptor.unwrap(), descriptor);
     assert_eq!(changeset_read.change_descriptor.unwrap(), change_descriptor);
 }
 
-pub fn persist_single_keychain<Db, CreateDb>(filename: &str, create_db: CreateDb)
+pub fn persist_single_keychain<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
-    CreateDb: Fn(&Path) -> anyhow::Result<Db>,
-    Db: WalletPersister,
-    Db::Error: Debug,
+    CreateStore: Fn(&Path) -> anyhow::Result<Store>,
+    Store: WalletPersister,
+    Store::Error: Debug,
 {
     // create db
-    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 mut store = create_test_store(filename, create_store);
 
     // initialize db
-    let changeset =
-        WalletPersister::initialize(&mut db).expect("should initialize and load empty changeset");
+    let changeset = WalletPersister::initialize(&mut store)
+        .expect("should initialize and load empty changeset");
     assert_eq!(changeset, ChangeSet::default());
 
-    let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[1].parse().unwrap();
+    let descriptor: Descriptor<DescriptorPublicKey> = DESCRIPTORS[0].parse().unwrap();
 
     let changeset = ChangeSet {
         descriptor: Some(descriptor.clone()),
         ..ChangeSet::default()
     };
 
-    WalletPersister::persist(&mut db, &changeset).expect("should persist descriptors");
+    WalletPersister::persist(&mut store, &changeset).expect("should persist descriptors");
 
     let changeset_read =
-        WalletPersister::initialize(&mut db).expect("should read persisted changeset");
+        WalletPersister::initialize(&mut store).expect("should read persisted changeset");
 
     assert_eq!(changeset_read.descriptor.unwrap(), descriptor);
     assert_eq!(changeset_read.change_descriptor, None);
