test: update tests/* to use KeyRing

The tests related to signers are yet to be fixed completely.

Author: 110CodingP

src/persist_test_utils.rs

@@ -34,6 +34,8 @@ use std::path::Path;
 use std::str::FromStr;
 use std::sync::Arc;
 
+use crate::KeychainKind;
+
 const DESCRIPTORS: [&str; 4] = [
     "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/0/*)#44aqnlam",
     "tr([5940b9b9/86'/0'/0']tpubDDVNqmq75GNPWQ9UNKfP43UwjaHU4GYfoPavojQbfpyfZp2KetWgjGBRRAy4tYCrAA6SB11mhQAkqxjh1VtQHyKwT4oYxpwLaGHvoKmtxZf/1/*)#ypcpw2dr",
@@ -66,6 +68,16 @@ fn spk_at_index(descriptor: &Descriptor<DescriptorPublicKey>, index: u32) -> Scr
         .script_pubkey()
 }
 
+// Check equalit of changesets.
+fn check_changesets(changeset1: &ChangeSet<KeychainKind>, changeset2: &ChangeSet<KeychainKind>) {
+    assert_eq!(changeset1.network, changeset2.network);
+    assert_eq!(changeset1.local_chain, changeset2.local_chain);
+    assert_eq!(changeset1.tx_graph, changeset2.tx_graph);
+    assert_eq!(changeset1.indexer, changeset2.indexer);
+    assert_eq!(changeset1.locked_outpoints, changeset2.locked_outpoints);
+    assert_eq!(changeset1.descriptors, changeset2.descriptors);
+}
+
 /// tests if [`Wallet`] is being persisted correctly
 ///
 /// [`Wallet`]: <https://docs.rs/bdk_wallet/latest/bdk_wallet/struct.Wallet.html>
@@ -77,7 +89,7 @@ fn spk_at_index(descriptor: &Descriptor<DescriptorPublicKey>, index: u32) -> Scr
 pub fn persist_wallet_changeset<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
     CreateStore: Fn(&Path) -> anyhow::Result<Store>,
-    Store: WalletPersister,
+    Store: WalletPersister<KeychainKind>,
     Store::Error: Debug,
 {
     // create store
@@ -172,6 +184,11 @@ where
         tx_graph: tx_graph_changeset,
         indexer: keychain_txout_changeset,
         locked_outpoints: locked_outpoints_changeset,
+        descriptors: [
+            (KeychainKind::External, descriptor.clone()),
+            (KeychainKind::Internal, change_descriptor),
+        ]
+        .into(),
     };
 
     // persist and load
@@ -180,7 +197,7 @@ where
     let changeset_read =
         WalletPersister::initialize(&mut store).expect("changeset should get loaded");
 
-    assert_eq!(changeset, changeset_read);
+    check_changesets(&changeset, &changeset_read);
 
     // create another changeset
     let local_chain_changeset = local_chain::ChangeSet {
@@ -231,6 +248,7 @@ where
         tx_graph: tx_graph_changeset,
         indexer: keychain_txout_changeset,
         locked_outpoints: locked_outpoints_changeset,
+        descriptors: [].into(),
     };
 
     // persist, load and check if same as merged
@@ -239,7 +257,7 @@ where
 
     changeset.merge(changeset_new);
 
-    assert_eq!(changeset, changeset_read_new);
+    check_changesets(&changeset, &changeset_read_new);
 }
 
 /// tests if multiple [`Wallet`]s can be persisted in a single file correctly
@@ -255,7 +273,7 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
     create_dbs: CreateStores,
 ) where
     CreateStores: Fn(&Path) -> anyhow::Result<(Store, Store)>,
-    Store: WalletPersister,
+    Store: WalletPersister<KeychainKind>,
     Store::Error: Debug,
 {
     // create stores
@@ -279,7 +297,8 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
         change_descriptor: Some(change_descriptor.clone()),
         network: Some(Network::Testnet),
         ..ChangeSet::default()
-    };
+    }
+    .from_v3();
 
     // persist first changeset
     WalletPersister::persist(&mut store_first, &changeset1).expect("should persist changeset");
@@ -298,20 +317,24 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
         change_descriptor: Some(change_descriptor.clone()),
         network: Some(Network::Testnet),
         ..ChangeSet::default()
-    };
+    }
+    .from_v3();
 
     // persist second changeset
     WalletPersister::persist(&mut store_sec, &changeset2).expect("should persist changeset");
 
     // load first changeset
     let changeset_read =
         WalletPersister::initialize(&mut store_first).expect("should load persisted changeset1");
-    assert_eq!(changeset_read, changeset1);
+
+    check_changesets(&changeset_read, &changeset1);
 
     // load second changeset
     let changeset_read =
         WalletPersister::initialize(&mut store_sec).expect("should load persisted changeset2");
     assert_eq!(changeset_read, changeset2);
+
+    check_changesets(&changeset_read, &changeset2);
 }
 
 /// tests if [`Network`] is being persisted correctly
@@ -324,7 +347,7 @@ pub fn persist_multiple_wallet_changesets<Store, CreateStores>(
 pub fn persist_network<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
     CreateStore: Fn(&Path) -> anyhow::Result<Store>,
-    Store: WalletPersister,
+    Store: WalletPersister<KeychainKind>,
     Store::Error: Debug,
 {
     // create store
@@ -360,7 +383,7 @@ where
 pub fn persist_keychains<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
     CreateStore: Fn(&Path) -> anyhow::Result<Store>,
-    Store: WalletPersister,
+    Store: WalletPersister<KeychainKind>,
     Store::Error: Debug,
 {
     // create store
@@ -381,16 +404,23 @@ where
         descriptor: Some(descriptor.clone()),
         change_descriptor: Some(change_descriptor.clone()),
         ..ChangeSet::default()
-    };
+    }
+    .from_v3();
 
     WalletPersister::persist(&mut store, &changeset).expect("should persist descriptors");
 
     // load the descriptors
     let changeset_read =
         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);
+    assert_eq!(
+        changeset_read.descriptors,
+        [
+            (KeychainKind::External, descriptor),
+            (KeychainKind::Internal, change_descriptor)
+        ]
+        .into()
+    );
 }
 
 /// tests if descriptor(in a single keychain wallet) is being persisted correctly
@@ -402,7 +432,7 @@ where
 pub fn persist_single_keychain<Store, CreateStore>(filename: &str, create_store: CreateStore)
 where
     CreateStore: Fn(&Path) -> anyhow::Result<Store>,
-    Store: WalletPersister,
+    Store: WalletPersister<KeychainKind>,
     Store::Error: Debug,
 {
     // create store
@@ -421,14 +451,17 @@ where
     let changeset = ChangeSet {
         descriptor: Some(descriptor.clone()),
         ..ChangeSet::default()
-    };
+    }
+    .from_v3();
 
     WalletPersister::persist(&mut store, &changeset).expect("should persist descriptors");
 
     // load the descriptor
     let changeset_read =
         WalletPersister::initialize(&mut store).expect("should read persisted changeset");
 
-    assert_eq!(changeset_read.descriptor.unwrap(), descriptor);
-    assert_eq!(changeset_read.change_descriptor, None);
+    assert_eq!(
+        changeset_read.descriptors,
+        [(KeychainKind::External, descriptor)].into()
+    );
 }

src/test_utils.rs

@@ -1,6 +1,5 @@
 //! `bdk_wallet` test utilities
 
-use alloc::string::ToString;
 use alloc::sync::Arc;
 use core::str::FromStr;
 
@@ -10,18 +9,24 @@ use bitcoin::{
     Transaction, TxIn, TxOut, Txid,
 };
 
-use crate::{KeychainKind, Update, Wallet};
+use crate::{KeyRing, KeychainKind, Update, Wallet};
 
 /// Return a fake wallet that appears to be funded for testing.
 ///
 /// The funded wallet contains a tx with a 76_000 sats input and two outputs, one spending 25_000
 /// to a foreign address and one returning 50_000 back to the wallet. The remaining 1000
 /// sats are the transaction fee.
-pub fn get_funded_wallet(descriptor: &str, change_descriptor: &str) -> (Wallet, Txid) {
+pub fn get_funded_wallet(
+    descriptor: &str,
+    change_descriptor: &str,
+) -> (Wallet<KeychainKind>, Txid) {
     new_funded_wallet(descriptor, Some(change_descriptor))
 }
 
-fn new_funded_wallet(descriptor: &str, change_descriptor: Option<&str>) -> (Wallet, Txid) {
+fn new_funded_wallet(
+    descriptor: &str,
+    change_descriptor: Option<&str>,
+) -> (Wallet<KeychainKind>, Txid) {
     let (mut wallet, txid, update) = new_wallet_and_funding_update(descriptor, change_descriptor);
     wallet.apply_update(update).unwrap();
     (wallet, txid)
@@ -32,12 +37,12 @@ fn new_funded_wallet(descriptor: &str, change_descriptor: Option<&str>) -> (Wall
 /// The funded wallet contains a tx with a 76_000 sats input and two outputs, one spending 25_000
 /// to a foreign address and one returning 50_000 back to the wallet. The remaining 1000
 /// sats are the transaction fee.
-pub fn get_funded_wallet_single(descriptor: &str) -> (Wallet, Txid) {
+pub fn get_funded_wallet_single(descriptor: &str) -> (Wallet<KeychainKind>, Txid) {
     new_funded_wallet(descriptor, None)
 }
 
 /// Get funded segwit wallet
-pub fn get_funded_wallet_wpkh() -> (Wallet, Txid) {
+pub fn get_funded_wallet_wpkh() -> (Wallet<KeychainKind>, Txid) {
     let (desc, change_desc) = get_test_wpkh_and_change_desc();
     get_funded_wallet(desc, change_desc)
 }
@@ -50,19 +55,28 @@ pub fn get_funded_wallet_wpkh() -> (Wallet, Txid) {
 pub fn new_wallet_and_funding_update(
     descriptor: &str,
     change_descriptor: Option<&str>,
-) -> (Wallet, Txid, Update) {
-    let params = if let Some(change_desc) = change_descriptor {
-        Wallet::create(descriptor.to_string(), change_desc.to_string())
-    } else {
-        Wallet::create_single(descriptor.to_string())
-    };
+) -> (Wallet<KeychainKind>, Txid, Update<KeychainKind>) {
+    let mut keyring = KeyRing::new(Network::Regtest);
+    keyring
+        .add_descriptor(KeychainKind::External, descriptor)
+        .expect("should add keychain");
+    if let Some(change_desc) = change_descriptor {
+        keyring
+            .add_descriptor(KeychainKind::Internal, change_desc)
+            .expect("should add keychain");
+    }
 
-    let wallet = params
-        .network(Network::Regtest)
+    let wallet = keyring
+        .into_params()
+        .expect("should be a valid keyring")
         .create_wallet_no_persist()
         .expect("descriptors must be valid");
 
-    let receive_address = wallet.peek_address(KeychainKind::External, 0).address;
+    let receive_address = wallet
+        .peek_address(KeychainKind::External, 0)
+        .expect("keychain must exist")
+        .expect("index is valid")
+        .address;
     let sendto_address = Address::from_str("bcrt1q3qtze4ys45tgdvguj66zrk4fu6hq3a3v9pfly5")
         .expect("address")
         .require_network(Network::Regtest)
@@ -253,7 +267,10 @@ impl From<ConfirmationBlockTime> for ReceiveTo {
 }
 
 /// Receive a tx output with the given value in the latest block
-pub fn receive_output_in_latest_block(wallet: &mut Wallet, value: Amount) -> OutPoint {
+pub fn receive_output_in_latest_block(
+    wallet: &mut Wallet<KeychainKind>,
+    value: Amount,
+) -> OutPoint {
     let latest_cp = wallet.latest_checkpoint();
     let height = latest_cp.height();
     assert!(height > 0, "cannot receive tx into genesis block");
@@ -269,17 +286,20 @@ pub fn receive_output_in_latest_block(wallet: &mut Wallet, value: Amount) -> Out
 
 /// Receive a tx output with the given value and chain position
 pub fn receive_output(
-    wallet: &mut Wallet,
+    wallet: &mut Wallet<KeychainKind>,
     value: Amount,
     receive_to: impl Into<ReceiveTo>,
 ) -> OutPoint {
-    let addr = wallet.next_unused_address(KeychainKind::External).address;
+    let addr = wallet
+        .next_unused_address(KeychainKind::External)
+        .expect("keychain must exist")
+        .address;
     receive_output_to_address(wallet, addr, value, receive_to)
 }
 
 /// Receive a tx output to an address with the given value and chain position
 pub fn receive_output_to_address(
-    wallet: &mut Wallet,
+    wallet: &mut Wallet<KeychainKind>,
     addr: Address,
     value: Amount,
     receive_to: impl Into<ReceiveTo>,
@@ -308,7 +328,7 @@ pub fn receive_output_to_address(
 /// Insert a checkpoint into the wallet. This can be used to extend the wallet's local chain
 /// or to insert a block that did not exist previously. Note that if replacing a block with
 /// a different one at the same height, then all later blocks are evicted as well.
-pub fn insert_checkpoint(wallet: &mut Wallet, block: BlockId) {
+pub fn insert_checkpoint(wallet: &mut Wallet<KeychainKind>, block: BlockId) {
     let mut cp = wallet.latest_checkpoint();
     cp = cp.insert(block);
     wallet
@@ -322,7 +342,7 @@ pub fn insert_checkpoint(wallet: &mut Wallet, block: BlockId) {
 /// 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) {
+pub fn insert_tx(wallet: &mut Wallet<KeychainKind>, tx: Transaction) {
     let txid = tx.compute_txid();
     let seen_at = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
     let mut tx_update = TxUpdate::default();
@@ -339,7 +359,7 @@ pub fn insert_tx(wallet: &mut Wallet, tx: Transaction) {
 /// 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) {
+pub fn insert_anchor(wallet: &mut Wallet<KeychainKind>, txid: Txid, anchor: ConfirmationBlockTime) {
     let mut tx_update = TxUpdate::default();
     tx_update.anchors = [(anchor, txid)].into();
     wallet
@@ -351,7 +371,7 @@ pub fn insert_anchor(wallet: &mut Wallet, txid: Txid, anchor: ConfirmationBlockT
 }
 
 /// Marks the given `txid` seen as unconfirmed at `seen_at`
-pub fn insert_seen_at(wallet: &mut Wallet, txid: Txid, seen_at: u64) {
+pub fn insert_seen_at(wallet: &mut Wallet<KeychainKind>, txid: Txid, seen_at: u64) {
     let mut tx_update = TxUpdate::default();
     tx_update.seen_ats = [(txid, seen_at)].into();
     wallet