Add SyncOptions as the second argument to Wallet::sync

The current options are awkware and it would be good if we could
introduce more in the future without breaking changes.

.github/workflows/cont_integration.yml

@@ -10,9 +10,9 @@ jobs:
     strategy:
       matrix:
         rust:
-          - version: 1.60.0 # STABLE
+          - version: 1.56.0 # STABLE
             clippy: true
-          - version: 1.56.1 # MSRV
+          - version: 1.46.0 # MSRV
         features:
           - default
           - minimal
@@ -28,7 +28,6 @@ jobs:
           - async-interface
           - use-esplora-reqwest
           - sqlite
-          - sqlite-bundled
     steps:
       - name: checkout
         uses: actions/checkout@v2
@@ -90,20 +89,13 @@ jobs:
       matrix:
         blockchain:
           - name: electrum
-            testprefix: blockchain::electrum::test
-            features: test-electrum,verify
+            features: test-electrum
           - name: rpc
-            testprefix: blockchain::rpc::test
             features: test-rpc
-          - name: rpc-legacy
-            testprefix: blockchain::rpc::test
-            features: test-rpc-legacy
           - name: esplora
-            testprefix: esplora
-            features: test-esplora,use-esplora-reqwest,verify
+            features: test-esplora,use-esplora-reqwest
           - name: esplora
-            testprefix: esplora
-            features: test-esplora,use-esplora-ureq,verify
+            features: test-esplora,use-esplora-ureq    
     steps:
       - name: Checkout
         uses: actions/checkout@v2
@@ -121,8 +113,8 @@ jobs:
           toolchain: stable
           override: true
       - name: Test
-        run: cargo test --no-default-features --features ${{ matrix.blockchain.features }} ${{ matrix.blockchain.testprefix }}::bdk_blockchain_tests
-
+        run: cargo test --no-default-features --features ${{ matrix.blockchain.features }} ${{ matrix.blockchain.name }}::bdk_blockchain_tests
+  
   check-wasm:
     name: Check WASM
     runs-on: ubuntu-20.04
@@ -146,7 +138,7 @@ jobs:
       - run: sudo apt-get update || exit 1
       - run: sudo apt-get install -y libclang-common-10-dev clang-10 libc6-dev-i386 || exit 1
       - name: Set default toolchain
-        run: rustup default 1.56.1 # STABLE
+        run: rustup default 1.56.0 # STABLE
       - name: Set profile
         run: rustup set profile minimal
       - name: Add target wasm32

.github/workflows/nightly_docs.yml

@@ -18,7 +18,7 @@ jobs:
             target
           key: nightly-docs-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
       - name: Set default toolchain
-        run: rustup default nightly-2022-01-25
+        run: rustup default nightly
       - name: Set profile
         run: rustup set profile minimal
       - name: Update toolchain

CHANGELOG.md

@@ -6,81 +6,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-
-## [v0.20.0] - [v0.19.0]
-
-- New MSRV set to `1.56.1`
-- Fee sniping discouraging through nLockTime - if the user specifies a `current_height`, we use that as a nlocktime, otherwise we use the last sync height (or 0 if we never synced)
-- Fix hang when `ElectrumBlockchainConfig::stop_gap` is zero.
-- Set coin type in BIP44, BIP49, and BIP84 templates
-- Get block hash given a block height - A `get_block_hash` method is now defined on the `GetBlockHash` trait and implemented on every blockchain backend. This method expects a block height and returns the corresponding block hash. 
-- Add `remove_partial_sigs` and `try_finalize` to `SignOptions`
-- Deprecate `AddressValidator`
-- Fix Electrum wallet sync potentially causing address index decrement - compare proposed index and current index before applying batch operations during sync.
-
-## [v0.19.0] - [v0.18.0]
-
-- added `OldestFirstCoinSelection` impl to `CoinSelectionAlgorithm`
-- New MSRV set to `1.56`
-- Unpinned tokio to `1`
-- Add traits to reuse `Blockchain`s across multiple wallets (`BlockchainFactory` and `StatelessBlockchain`).
-- Upgrade to rust-bitcoin `0.28`
-- If using the `sqlite-db` feature all cached wallet data is deleted due to a possible UTXO inconsistency, a wallet.sync will recreate it  
-- Update `PkOrF` in the policy module to become an enum
-- Add experimental support for Taproot, including:
-  - Support for `tr()` descriptors with complex tapscript trees
-  - Creation of Taproot PSBTs (BIP-371)
-  - Signing Taproot PSBTs (key spend and script spend)
-  - Support for `tr()` descriptors in the `descriptor!()` macro
-- Add support for Bitcoin Core 23.0 when using the `rpc` blockchain
-
-## [v0.18.0] - [v0.17.0]
-
-- Add `sqlite-bundled` feature for deployments that need a bundled version of sqlite, ie. for mobile platforms.
-- Added `Wallet::get_signers()`, `Wallet::descriptor_checksum()` and `Wallet::get_address_validators()`, exposed the `AsDerived` trait.
-- Deprecate `database::Database::flush()`, the function is only needed for the sled database on mobile, instead for mobile use the sqlite database.
-- Add `keychain: KeychainKind` to `wallet::AddressInfo`.
-- Improve key generation traits
-- Rename `WalletExport` to `FullyNodedExport`, deprecate the former.
-- Bump `miniscript` dependency version to `^6.1`. 
-
-## [v0.17.0] - [v0.16.1]
-
-- Removed default verification from `wallet::sync`. sync-time verification is added in `script_sync` and is activated by `verify` feature flag.
-- `verify` flag removed from `TransactionDetails`.
-- Add `get_internal_address` to allow you to get internal addresses just as you get external addresses.
-- added `ensure_addresses_cached` to `Wallet` to let offline wallets load and cache addresses in their database
-- Add `is_spent` field to `LocalUtxo`; when we notice that a utxo has been spent we set `is_spent` field to true instead of deleting it from the db.
-
 ### Sync API change
 
 To decouple the `Wallet` from the `Blockchain` we've made major changes:
 
 - Removed `Blockchain` from Wallet.
 - Removed `Wallet::broadcast` (just use `Blockchain::broadcast`)
-- Deprecated `Wallet::new_offline` (all wallets are offline now)
+- Depreciated `Wallet::new_offline` (all wallets are offline now)
 - Changed `Wallet::sync` to take a `Blockchain`.
 - Stop making a request for the block height when calling `Wallet:new`.
 - Added `SyncOptions` to capture extra (future) arguments to `Wallet::sync`.
-- Removed `max_addresses` sync parameter which determined how many addresses to cache before syncing since this can just be done with `ensure_addresses_cached`.
-- remove `flush` method from the `Database` trait.
-
-## [v0.16.1] - [v0.16.0]
-
-- Pin tokio dependency version to ~1.14 to prevent errors due to their new MSRV 1.49.0
-
-## [v0.16.0] - [v0.15.0]
-
-- Disable `reqwest` default features.
-- Added `reqwest-default-tls` feature: Use this to restore the TLS defaults of reqwest if you don't want to add a dependency to it in your own manifest.
-- Use dust_value from rust-bitcoin
-- Fixed generating WIF in the correct network format.
 
 ## [v0.15.0] - [v0.14.0]
 
 - Overhauled sync logic for electrum and esplora.
 - Unify ureq and reqwest esplora backends to have the same configuration parameters. This means reqwest now has a timeout parameter and ureq has a concurrency parameter.
 - Fixed esplora fee estimation.
+- Fixed generating WIF in the correct network format.
+- Disable `reqwest` default features.
+- Added `reqwest-default-tls` feature: Use this to restore the TLS defaults of reqwest if you don't want to add a dependency to it in your own manifest.
 
 ## [v0.14.0] - [v0.13.0]
 
@@ -457,6 +401,7 @@ final transaction is created by calling `finish` on the builder.
 - Use `MemoryDatabase` in the compiler example
 - Make the REPL return JSON
 
+[unreleased]: https://github.com/bitcoindevkit/bdk/compare/v0.11.0...HEAD
 [0.1.0-beta.1]: https://github.com/bitcoindevkit/bdk/compare/96c87ea5...0.1.0-beta.1
 [v0.2.0]: https://github.com/bitcoindevkit/bdk/compare/0.1.0-beta.1...v0.2.0
 [v0.3.0]: https://github.com/bitcoindevkit/bdk/compare/v0.2.0...v0.3.0
@@ -473,10 +418,3 @@ final transaction is created by calling `finish` on the builder.
 [v0.13.0]: https://github.com/bitcoindevkit/bdk/compare/v0.12.0...v0.13.0
 [v0.14.0]: https://github.com/bitcoindevkit/bdk/compare/v0.13.0...v0.14.0
 [v0.15.0]: https://github.com/bitcoindevkit/bdk/compare/v0.14.0...v0.15.0
-[v0.16.0]: https://github.com/bitcoindevkit/bdk/compare/v0.15.0...v0.16.0
-[v0.16.1]: https://github.com/bitcoindevkit/bdk/compare/v0.16.0...v0.16.1
-[v0.17.0]: https://github.com/bitcoindevkit/bdk/compare/v0.16.1...v0.17.0
-[v0.18.0]: https://github.com/bitcoindevkit/bdk/compare/v0.17.0...v0.18.0
-[v0.19.0]: https://github.com/bitcoindevkit/bdk/compare/v0.18.0...v0.19.0
-[v0.20.0]: https://github.com/bitcoindevkit/bdk/compare/v0.19.0...v0.20.0
-[unreleased]: https://github.com/bitcoindevkit/bdk/compare/v0.20.0...HEAD

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bdk"
-version = "0.20.0"
+version = "0.15.1-dev"
 edition = "2018"
 authors = ["Alekos Filini <alekos.filini@gmail.com>", "Riccardo Casatta <riccardo@casatta.it>"]
 homepage = "https://bitcoindevkit.org"
@@ -14,17 +14,17 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 bdk-macros = "^0.6"
 log = "^0.4"
-miniscript = { version = "7.0", features = ["use-serde"] }
-bitcoin = { version = "0.28.1", features = ["use-serde", "base64", "rand"] }
+miniscript = { version = "^6.0", features = ["use-serde"] }
+bitcoin = { version = "^0.27", features = ["use-serde", "base64"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 rand = "^0.7"
 
 # Optional dependencies
 sled = { version = "0.34", optional = true }
-electrum-client = { version = "0.10", optional = true }
-rusqlite = { version = "0.27.0", optional = true }
-ahash = { version = "0.7.6", optional = true }
+electrum-client = { version = "0.8", optional = true }
+rusqlite = { version = "0.25.3", optional = true }
+ahash = { version = "=0.7.4", optional = true }
 reqwest = { version = "0.11", optional = true, default-features = false, features = ["json"] }
 ureq = { version = "~2.2.0", features = ["json"], optional = true }
 futures = { version = "0.3", optional = true }
@@ -37,8 +37,8 @@ lazy_static = { version = "1.4", optional = true }
 bip39 = { version = "1.0.1", optional = true }
 bitcoinconsensus = { version = "0.19.0-3", optional = true }
 
-# Needed by bdk_blockchain_tests macro and the `rpc` feature
-bitcoincore-rpc = { version = "0.15", optional = true }
+# Needed by bdk_blockchain_tests macro
+bitcoincore-rpc = { version = "0.14", optional = true }
 
 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -55,7 +55,6 @@ compiler = ["miniscript/compiler"]
 verify = ["bitcoinconsensus"]
 default = ["key-value-db", "electrum"]
 sqlite = ["rusqlite", "ahash"]
-sqlite-bundled = ["sqlite", "rusqlite/bundled"]
 compact_filters = ["rocksdb", "socks", "lazy_static", "cc"]
 key-value-db = ["sled"]
 all-keys = ["keys-bip39"]
@@ -88,17 +87,16 @@ reqwest-default-tls = ["reqwest/default-tls"]
 
 # Debug/Test features
 test-blockchains = ["bitcoincore-rpc", "electrum-client"]
-test-electrum = ["electrum", "electrsd/electrs_0_8_10", "electrsd/bitcoind_22_0", "test-blockchains"]
-test-rpc = ["rpc", "electrsd/electrs_0_8_10", "electrsd/bitcoind_22_0", "test-blockchains"]
-test-rpc-legacy = ["rpc", "electrsd/electrs_0_8_10", "electrsd/bitcoind_0_20_0", "test-blockchains"]
-test-esplora = ["electrsd/legacy", "electrsd/esplora_a33e97e1", "electrsd/bitcoind_22_0", "test-blockchains"]
+test-electrum = ["electrum", "electrsd/electrs_0_8_10", "test-blockchains"]
+test-rpc = ["rpc", "electrsd/electrs_0_8_10", "test-blockchains"]
+test-esplora = ["electrsd/legacy", "electrsd/esplora_a33e97e1", "test-blockchains"]
 test-md-docs = ["electrum"]
 
 [dev-dependencies]
 lazy_static = "1.4"
 env_logger = "0.7"
 clap = "2.33"
-electrsd = "0.19.1"
+electrsd = { version= "0.13", features = ["trigger", "bitcoind_22_0"] }
 
 [[example]]
 name = "address_validator"
@@ -111,11 +109,6 @@ name = "miniscriptc"
 path = "examples/compiler.rs"
 required-features = ["compiler"]
 
-[[example]]
-name = "rpcwallet"
-path = "examples/rpcwallet.rs"
-required-features = ["keys-bip39", "key-value-db", "rpc"]
-
 [workspace]
 members = ["macros"]
 [package.metadata.docs.rs]

README.md

@@ -13,7 +13,7 @@
     <a href="https://github.com/bitcoindevkit/bdk/actions?query=workflow%3ACI"><img alt="CI Status" src="https://github.com/bitcoindevkit/bdk/workflows/CI/badge.svg"></a>
     <a href="https://codecov.io/gh/bitcoindevkit/bdk"><img src="https://codecov.io/gh/bitcoindevkit/bdk/branch/master/graph/badge.svg"/></a>
     <a href="https://docs.rs/bdk"><img alt="API Docs" src="https://img.shields.io/badge/docs.rs-bdk-green"/></a>
-    <a href="https://blog.rust-lang.org/2021/11/01/Rust-1.56.1.html"><img alt="Rustc Version 1.56.1+" src="https://img.shields.io/badge/rustc-1.56.1%2B-lightgrey.svg"/></a>
+    <a href="https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html"><img alt="Rustc Version 1.46+" src="https://img.shields.io/badge/rustc-1.46%2B-lightgrey.svg"/></a>
     <a href="https://discord.gg/d7NkDKm"><img alt="Chat on Discord" src="https://img.shields.io/discord/753336465005608961?logo=discord"></a>
   </p>
 
@@ -43,15 +43,15 @@ use bdk::Wallet;
 use bdk::database::MemoryDatabase;
 use bdk::blockchain::ElectrumBlockchain;
 use bdk::SyncOptions;
+
 use bdk::electrum_client::Client;
-use bdk::bitcoin::Network;
 
 fn main() -> Result<(), bdk::Error> {
     let blockchain = ElectrumBlockchain::from(Client::new("ssl://electrum.blockstream.info:60002")?);
     let wallet = Wallet::new(
         "wpkh([c258d2e4/84h/1h/0h]tpubDDYkZojQFQjht8Tm4jsS3iuEmKjTiEGjG6KnuFNKKJb5A6ZUCUZKdvLdSDWofKi4ToRCwb9poe1XdqfUnP4jaJjCB2Zwv11ZLgSbnZSNecE/0/*)",
         Some("wpkh([c258d2e4/84h/1h/0h]tpubDDYkZojQFQjht8Tm4jsS3iuEmKjTiEGjG6KnuFNKKJb5A6ZUCUZKdvLdSDWofKi4ToRCwb9poe1XdqfUnP4jaJjCB2Zwv11ZLgSbnZSNecE/1/*)"),
-        Network::Testnet,
+        bitcoin::Network::Testnet,
         MemoryDatabase::default(),
     )?;
 
@@ -166,7 +166,7 @@ Integration testing require testing features, for example:
 cargo test --features test-electrum
 ```
 
-The other options are `test-esplora`, `test-rpc` or `test-rpc-legacy` which runs against an older version of Bitcoin Core.
+The other options are `test-esplora` or `test-rpc`.
 Note that `electrs` and `bitcoind` binaries are automatically downloaded (on mac and linux), to specify you already have installed binaries you must use `--no-default-features` and provide `BITCOIND_EXE` and `ELECTRS_EXE` as environment variables.
 
 ## License

examples/address_validator.rs

@@ -14,7 +14,6 @@ use std::sync::Arc;
 use bdk::bitcoin;
 use bdk::database::MemoryDatabase;
 use bdk::descriptor::HdKeyPaths;
-#[allow(deprecated)]
 use bdk::wallet::address_validator::{AddressValidator, AddressValidatorError};
 use bdk::KeychainKind;
 use bdk::Wallet;
@@ -26,7 +25,6 @@ use bitcoin::{Network, Script};
 
 #[derive(Debug)]
 struct DummyValidator;
-#[allow(deprecated)]
 impl AddressValidator for DummyValidator {
     fn validate(
         &self,
@@ -52,7 +50,6 @@ fn main() -> Result<(), bdk::Error> {
     let descriptor = "sh(and_v(v:pk(tpubDDpWvmUrPZrhSPmUzCMBHffvC3HyMAPnWDSAQNBTnj1iZeJa7BZQEttFiP4DS4GCcXQHezdXhn86Hj6LHX5EDstXPWrMaSneRWM8yUf6NFd/*),after(630000)))";
     let mut wallet = Wallet::new(descriptor, None, Network::Regtest, MemoryDatabase::new())?;
 
-    #[allow(deprecated)]
     wallet.add_address_validator(Arc::new(DummyValidator));
 
     wallet.get_address(New)?;

examples/compiler.rs

@@ -85,7 +85,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let network = matches
         .value_of("network")
-        .map(Network::from_str)
+        .map(|n| Network::from_str(n))
         .transpose()
         .unwrap()
         .unwrap_or(Network::Testnet);

examples/rpcwallet.rs

@@ -1,229 +0,0 @@
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-use bdk::bitcoin::secp256k1::Secp256k1;
-use bdk::bitcoin::Amount;
-use bdk::bitcoin::Network;
-use bdk::bitcoincore_rpc::RpcApi;
-
-use bdk::blockchain::rpc::{Auth, RpcBlockchain, RpcConfig};
-use bdk::blockchain::ConfigurableBlockchain;
-
-use bdk::keys::bip39::{Language, Mnemonic, WordCount};
-use bdk::keys::{DerivableKey, GeneratableKey, GeneratedKey};
-
-use bdk::miniscript::miniscript::Segwitv0;
-
-use bdk::sled;
-use bdk::template::Bip84;
-use bdk::wallet::{signer::SignOptions, wallet_name_from_descriptor, AddressIndex, SyncOptions};
-use bdk::KeychainKind;
-use bdk::Wallet;
-
-use bdk::blockchain::Blockchain;
-
-use electrsd;
-
-use std::error::Error;
-use std::path::PathBuf;
-use std::str::FromStr;
-
-/// This example demonstrates a typical way to create a wallet and work with bdk.
-///
-/// This example bdk wallet is connected to a bitcoin core rpc regtest node,
-/// and will attempt to receive, create and broadcast transactions.
-///
-/// To start a bitcoind regtest node programmatically, this example uses
-/// `electrsd` library, which is also a bdk dev-dependency.
-///
-/// But you can start your own bitcoind backend, and the rest of the example should work fine.
-
-fn main() -> Result<(), Box<dyn Error>> {
-    // -- Setting up background bitcoind process
-
-    println!(">> Setting up bitcoind");
-
-    // Start the bitcoind process
-    let bitcoind_conf = electrsd::bitcoind::Conf::default();
-
-    // electrsd will automatically download the bitcoin core binaries
-    let bitcoind_exe =
-        electrsd::bitcoind::downloaded_exe_path().expect("We should always have downloaded path");
-
-    // Launch bitcoind and gather authentication access
-    let bitcoind = electrsd::bitcoind::BitcoinD::with_conf(bitcoind_exe, &bitcoind_conf).unwrap();
-    let bitcoind_auth = Auth::Cookie {
-        file: bitcoind.params.cookie_file.clone(),
-    };
-
-    // Get a new core address
-    let core_address = bitcoind.client.get_new_address(None, None)?;
-
-    // Generate 101 blocks and use the above address as coinbase
-    bitcoind.client.generate_to_address(101, &core_address)?;
-
-    println!(">> bitcoind setup complete");
-    println!(
-        "Available coins in Core wallet : {}",
-        bitcoind.client.get_balance(None, None)?
-    );
-
-    // -- Setting up the Wallet
-
-    println!("\n>> Setting up BDK wallet");
-
-    // Get a random private key
-    let xprv = generate_random_ext_privkey()?;
-
-    // Use the derived descriptors from the privatekey to
-    // create unique wallet name.
-    // This is a special utility function exposed via `bdk::wallet_name_from_descriptor()`
-    let wallet_name = wallet_name_from_descriptor(
-        Bip84(xprv.clone(), KeychainKind::External),
-        Some(Bip84(xprv.clone(), KeychainKind::Internal)),
-        Network::Regtest,
-        &Secp256k1::new(),
-    )?;
-
-    // Create a database (using default sled type) to store wallet data
-    let mut datadir = PathBuf::from_str("/tmp/")?;
-    datadir.push(".bdk-example");
-    let database = sled::open(datadir)?;
-    let database = database.open_tree(wallet_name.clone())?;
-
-    // Create a RPC configuration of the running bitcoind backend we created in last step
-    // Note: If you are using custom regtest node, use the appropriate url and auth
-    let rpc_config = RpcConfig {
-        url: bitcoind.params.rpc_socket.to_string(),
-        auth: bitcoind_auth,
-        network: Network::Regtest,
-        wallet_name,
-        skip_blocks: None,
-    };
-
-    // Use the above configuration to create a RPC blockchain backend
-    let blockchain = RpcBlockchain::from_config(&rpc_config)?;
-
-    // Combine Database + Descriptor to create the final wallet
-    let wallet = Wallet::new(
-        Bip84(xprv.clone(), KeychainKind::External),
-        Some(Bip84(xprv.clone(), KeychainKind::Internal)),
-        Network::Regtest,
-        database,
-    )?;
-
-    // The `wallet` and the `blockchain` are independent structs.
-    // The wallet will be used to do all wallet level actions
-    // The blockchain can be used to do all blockchain level actions.
-    // For certain actions (like sync) the wallet will ask for a blockchain.
-
-    // Sync the wallet
-    // The first sync is important as this will instantiate the
-    // wallet files.
-    wallet.sync(&blockchain, SyncOptions::default())?;
-
-    println!(">> BDK wallet setup complete.");
-    println!(
-        "Available initial coins in BDK wallet : {} sats",
-        wallet.get_balance()?
-    );
-
-    // -- Wallet transaction demonstration
-
-    println!("\n>> Sending coins: Core --> BDK, 10 BTC");
-    // Get a new address to receive coins
-    let bdk_new_addr = wallet.get_address(AddressIndex::New)?.address;
-
-    // Send 10 BTC from core wallet to bdk wallet
-    bitcoind.client.send_to_address(
-        &bdk_new_addr,
-        Amount::from_btc(10.0)?,
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-    )?;
-
-    // Confirm transaction by generating 1 block
-    bitcoind.client.generate_to_address(1, &core_address)?;
-
-    // Sync the BDK wallet
-    // This time the sync will fetch the new transaction and update it in
-    // wallet database
-    wallet.sync(&blockchain, SyncOptions::default())?;
-
-    println!(">> Received coins in BDK wallet");
-    println!(
-        "Available balance in BDK wallet: {} sats",
-        wallet.get_balance()?
-    );
-
-    println!("\n>> Sending coins: BDK --> Core, 5 BTC");
-    // Attempt to send back 5.0 BTC to core address by creating a transaction
-    //
-    // Transactions are created using a `TxBuilder`.
-    // This helps us to systematically build a transaction with all
-    // required customization.
-    // A full list of APIs offered by `TxBuilder` can be found at
-    // https://docs.rs/bdk/latest/bdk/wallet/tx_builder/struct.TxBuilder.html
-    let mut tx_builder = wallet.build_tx();
-
-    // For a regular transaction, just set the recipient and amount
-    tx_builder.set_recipients(vec![(core_address.script_pubkey(), 500000000)]);
-
-    // Finalize the transaction and extract the PSBT
-    let (mut psbt, _) = tx_builder.finish()?;
-
-    // Set signing option
-    let signopt = SignOptions {
-        assume_height: None,
-        ..Default::default()
-    };
-
-    // Sign the psbt
-    wallet.sign(&mut psbt, signopt)?;
-
-    // Extract the signed transaction
-    let tx = psbt.extract_tx();
-
-    // Broadcast the transaction
-    blockchain.broadcast(&tx)?;
-
-    // Confirm transaction by generating some blocks
-    bitcoind.client.generate_to_address(1, &core_address)?;
-
-    // Sync the BDK wallet
-    wallet.sync(&blockchain, SyncOptions::default())?;
-
-    println!(">> Coins sent to Core wallet");
-    println!(
-        "Remaining BDK wallet balance: {} sats",
-        wallet.get_balance()?
-    );
-    println!("\nCongrats!! you made your first test transaction with bdk and bitcoin core.");
-
-    Ok(())
-}
-
-// Helper function demonstrating privatekey extraction using bip39 mnemonic
-// The mnemonic can be shown to user to safekeeping and the same wallet
-// private descriptors can be recreated from it.
-fn generate_random_ext_privkey() -> Result<impl DerivableKey<Segwitv0> + Clone, Box<dyn Error>> {
-    // a Bip39 passphrase can be set optionally
-    let password = Some("random password".to_string());
-
-    // Generate a random mnemonic, and use that to create a "DerivableKey"
-    let mnemonic: GeneratedKey<_, _> = Mnemonic::generate((WordCount::Words12, Language::English))
-        .map_err(|e| e.expect("Unknown Error"))?;
-
-    // `Ok(mnemonic)` would also work if there's no passphrase and it would
-    // yield the same result as this construct with `password` = `None`.
-    Ok((mnemonic, password))
-}

src/blockchain/any.rs

@@ -16,7 +16,7 @@
 //!
 //! ## Example
 //!
-//! When paired with the use of [`ConfigurableBlockchain`], it allows creating any
+//! When paired with the use of [`ConfigurableBlockchain`], it allows creating wallets with any
 //! blockchain type supported using a single line of code:
 //!
 //! ```no_run
@@ -34,14 +34,6 @@
 use super::*;
 
 macro_rules! impl_from {
-    ( boxed $from:ty, $to:ty, $variant:ident, $( $cfg:tt )* ) => {
-        $( $cfg )*
-        impl From<$from> for $to {
-            fn from(inner: $from) -> Self {
-                <$to>::$variant(Box::new(inner))
-            }
-        }
-    };
     ( $from:ty, $to:ty, $variant:ident, $( $cfg:tt )* ) => {
         $( $cfg )*
         impl From<$from> for $to {
@@ -76,19 +68,19 @@ pub enum AnyBlockchain {
     #[cfg(feature = "electrum")]
     #[cfg_attr(docsrs, doc(cfg(feature = "electrum")))]
     /// Electrum client
-    Electrum(Box<electrum::ElectrumBlockchain>),
+    Electrum(electrum::ElectrumBlockchain),
     #[cfg(feature = "esplora")]
     #[cfg_attr(docsrs, doc(cfg(feature = "esplora")))]
     /// Esplora client
-    Esplora(Box<esplora::EsploraBlockchain>),
+    Esplora(esplora::EsploraBlockchain),
     #[cfg(feature = "compact_filters")]
     #[cfg_attr(docsrs, doc(cfg(feature = "compact_filters")))]
     /// Compact filters client
-    CompactFilters(Box<compact_filters::CompactFiltersBlockchain>),
+    CompactFilters(compact_filters::CompactFiltersBlockchain),
     #[cfg(feature = "rpc")]
     #[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
     /// RPC client
-    Rpc(Box<rpc::RpcBlockchain>),
+    Rpc(rpc::RpcBlockchain),
 }
 
 #[maybe_async]
@@ -97,6 +89,9 @@ impl Blockchain for AnyBlockchain {
         maybe_await!(impl_inner_method!(self, get_capabilities))
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        maybe_await!(impl_inner_method!(self, get_tx, txid))
+    }
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         maybe_await!(impl_inner_method!(self, broadcast, tx))
     }
@@ -106,28 +101,12 @@ impl Blockchain for AnyBlockchain {
     }
 }
 
-#[maybe_async]
 impl GetHeight for AnyBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
         maybe_await!(impl_inner_method!(self, get_height))
     }
 }
 
-#[maybe_async]
-impl GetTx for AnyBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        maybe_await!(impl_inner_method!(self, get_tx, txid))
-    }
-}
-
-#[maybe_async]
-impl GetBlockHash for AnyBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        maybe_await!(impl_inner_method!(self, get_block_hash, height))
-    }
-}
-
-#[maybe_async]
 impl WalletSync for AnyBlockchain {
     fn wallet_sync<D: BatchDatabase>(
         &self,
@@ -156,10 +135,10 @@ impl WalletSync for AnyBlockchain {
     }
 }
 
-impl_from!(boxed electrum::ElectrumBlockchain, AnyBlockchain, Electrum, #[cfg(feature = "electrum")]);
-impl_from!(boxed esplora::EsploraBlockchain, AnyBlockchain, Esplora, #[cfg(feature = "esplora")]);
-impl_from!(boxed compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilters, #[cfg(feature = "compact_filters")]);
-impl_from!(boxed rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]);
+impl_from!(electrum::ElectrumBlockchain, AnyBlockchain, Electrum, #[cfg(feature = "electrum")]);
+impl_from!(esplora::EsploraBlockchain, AnyBlockchain, Esplora, #[cfg(feature = "esplora")]);
+impl_from!(compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilters, #[cfg(feature = "compact_filters")]);
+impl_from!(rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]);
 
 /// Type that can contain any of the blockchain configurations defined by the library
 ///
@@ -222,19 +201,19 @@ impl ConfigurableBlockchain for AnyBlockchain {
         Ok(match config {
             #[cfg(feature = "electrum")]
             AnyBlockchainConfig::Electrum(inner) => {
-                AnyBlockchain::Electrum(Box::new(electrum::ElectrumBlockchain::from_config(inner)?))
+                AnyBlockchain::Electrum(electrum::ElectrumBlockchain::from_config(inner)?)
             }
             #[cfg(feature = "esplora")]
             AnyBlockchainConfig::Esplora(inner) => {
-                AnyBlockchain::Esplora(Box::new(esplora::EsploraBlockchain::from_config(inner)?))
+                AnyBlockchain::Esplora(esplora::EsploraBlockchain::from_config(inner)?)
             }
             #[cfg(feature = "compact_filters")]
-            AnyBlockchainConfig::CompactFilters(inner) => AnyBlockchain::CompactFilters(Box::new(
+            AnyBlockchainConfig::CompactFilters(inner) => AnyBlockchain::CompactFilters(
                 compact_filters::CompactFiltersBlockchain::from_config(inner)?,
-            )),
+            ),
             #[cfg(feature = "rpc")]
             AnyBlockchainConfig::Rpc(inner) => {
-                AnyBlockchain::Rpc(Box::new(rpc::RpcBlockchain::from_config(inner)?))
+                AnyBlockchain::Rpc(rpc::RpcBlockchain::from_config(inner)?)
             }
         })
     }

src/blockchain/compact_filters/mod.rs

@@ -67,7 +67,7 @@ mod peer;
 mod store;
 mod sync;
 
-use crate::blockchain::*;
+use super::{Blockchain, Capability, ConfigurableBlockchain, GetHeight, Progress, WalletSync};
 use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
 use crate::error::Error;
 use crate::types::{KeychainKind, LocalUtxo, TransactionDetails};
@@ -163,19 +163,11 @@ impl CompactFiltersBlockchain {
             if let Some(previous_output) = database.get_previous_output(&input.previous_output)? {
                 inputs_sum += previous_output.value;
 
-                // this output is ours, we have a path to derive it
-                if let Some((keychain, _)) =
-                    database.get_path_from_script_pubkey(&previous_output.script_pubkey)?
-                {
+                if database.is_mine(&previous_output.script_pubkey)? {
                     outgoing += previous_output.value;
 
-                    debug!("{} input #{} is mine, setting utxo as spent", tx.txid(), i);
-                    updates.set_utxo(&LocalUtxo {
-                        outpoint: input.previous_output,
-                        txout: previous_output.clone(),
-                        keychain,
-                        is_spent: true,
-                    })?;
+                    debug!("{} input #{} is mine, removing from utxo", tx.txid(), i);
+                    updates.del_utxo(&input.previous_output)?;
                 }
             }
         }
@@ -193,7 +185,6 @@ impl CompactFiltersBlockchain {
                     outpoint: OutPoint::new(tx.txid(), i as u32),
                     txout: output.clone(),
                     keychain,
-                    is_spent: false,
                 })?;
                 incoming += output.value;
 
@@ -216,6 +207,7 @@ impl CompactFiltersBlockchain {
                 received: incoming,
                 sent: outgoing,
                 confirmation_time: BlockTime::new(height, timestamp),
+                verified: height.is_some(),
                 fee: Some(inputs_sum.saturating_sub(outputs_sum)),
             };
 
@@ -234,6 +226,12 @@ impl Blockchain for CompactFiltersBlockchain {
         vec![Capability::FullHistory].into_iter().collect()
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(self.peers[0]
+            .get_mempool()
+            .get_tx(&Inventory::Transaction(*txid)))
+    }
+
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         self.peers[0].broadcast_tx(tx.clone())?;
 
@@ -252,24 +250,6 @@ impl GetHeight for CompactFiltersBlockchain {
     }
 }
 
-impl GetTx for CompactFiltersBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.peers[0]
-            .get_mempool()
-            .get_tx(&Inventory::Transaction(*txid)))
-    }
-}
-
-impl GetBlockHash for CompactFiltersBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        self.headers
-            .get_block_hash(height as usize)?
-            .ok_or(Error::CompactFilters(
-                CompactFiltersError::BlockHashNotFound,
-            ))
-    }
-}
-
 impl WalletSync for CompactFiltersBlockchain {
     #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
     fn wallet_setup<D: BatchDatabase>(
@@ -546,8 +526,6 @@ pub enum CompactFiltersError {
     InvalidFilter,
     /// The peer is missing a block in the valid chain
     MissingBlock,
-    /// Block hash at specified height not found
-    BlockHashNotFound,
     /// The data stored in the block filters storage are corrupted
     DataCorruption,
 

src/blockchain/compact_filters/peer.rs

@@ -10,7 +10,6 @@
 // licenses.
 
 use std::collections::HashMap;
-use std::io::BufReader;
 use std::net::{TcpStream, ToSocketAddrs};
 use std::sync::{Arc, Condvar, Mutex, RwLock};
 use std::thread;
@@ -20,13 +19,14 @@ use socks::{Socks5Stream, ToTargetAddr};
 
 use rand::{thread_rng, Rng};
 
-use bitcoin::consensus::{Decodable, Encodable};
+use bitcoin::consensus::Encodable;
 use bitcoin::hash_types::BlockHash;
 use bitcoin::network::constants::ServiceFlags;
 use bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
 use bitcoin::network::message_blockdata::*;
 use bitcoin::network::message_filter::*;
 use bitcoin::network::message_network::VersionMessage;
+use bitcoin::network::stream_reader::StreamReader;
 use bitcoin::network::Address;
 use bitcoin::{Block, Network, Transaction, Txid, Wtxid};
 
@@ -94,7 +94,8 @@ impl Mempool {
             TxIdentifier::Wtxid(wtxid) => self.0.read().unwrap().wtxids.get(&wtxid).cloned(),
         };
 
-        txid.and_then(|txid| self.0.read().unwrap().txs.get(&txid).cloned())
+        txid.map(|txid| self.0.read().unwrap().txs.get(&txid).cloned())
+            .flatten()
     }
 
     /// Return whether or not the mempool contains a transaction with a given txid
@@ -110,7 +111,6 @@ impl Mempool {
 
 /// A Bitcoin peer
 #[derive(Debug)]
-#[allow(dead_code)]
 pub struct Peer {
     writer: Arc<Mutex<TcpStream>>,
     responses: Arc<RwLock<ResponsesMap>>,
@@ -327,10 +327,9 @@ impl Peer {
             };
         }
 
-        let mut reader = BufReader::new(connection);
+        let mut reader = StreamReader::new(connection, None);
         loop {
-            let raw_message: RawNetworkMessage =
-                check_disconnect!(Decodable::consensus_decode(&mut reader));
+            let raw_message: RawNetworkMessage = check_disconnect!(reader.read_next());
 
             let in_message = if raw_message.magic != network.magic() {
                 continue;

src/blockchain/electrum.rs

@@ -68,6 +68,10 @@ impl Blockchain for ElectrumBlockchain {
         .collect()
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(self.client.transaction_get(txid).map(Option::Some)?)
+    }
+
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         Ok(self.client.transaction_broadcast(tx).map(|_| ())?)
     }
@@ -79,8 +83,6 @@ impl Blockchain for ElectrumBlockchain {
     }
 }
 
-impl StatelessBlockchain for ElectrumBlockchain {}
-
 impl GetHeight for ElectrumBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
         // TODO: unsubscribe when added to the client, or is there a better call to use here?
@@ -92,19 +94,6 @@ impl GetHeight for ElectrumBlockchain {
     }
 }
 
-impl GetTx for ElectrumBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.client.transaction_get(txid).map(Option::Some)?)
-    }
-}
-
-impl GetBlockHash for ElectrumBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        let block_header = self.client.block_header(height as usize)?;
-        Ok(block_header.block_hash())
-    }
-}
-
 impl WalletSync for ElectrumBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
@@ -115,10 +104,7 @@ impl WalletSync for ElectrumBlockchain {
         let mut block_times = HashMap::<u32, u32>::new();
         let mut txid_to_height = HashMap::<Txid, u32>::new();
         let mut tx_cache = TxCache::new(database, &self.client);
-
-        // Set chunk_size to the smallest value capable of finding a gap greater than stop_gap.
-        let chunk_size = self.stop_gap + 1;
-
+        let chunk_size = self.stop_gap;
         // The electrum server has been inconsistent somehow in its responses during sync. For
         // example, we do a batch request of transactions and the response contains less
         // tranascations than in the request. This should never happen but we don't want to panic.
@@ -154,12 +140,21 @@ impl WalletSync for ElectrumBlockchain {
 
                 Request::Conftime(conftime_req) => {
                     // collect up to chunk_size heights to fetch from electrum
-                    let needs_block_height = conftime_req
-                        .request()
-                        .filter_map(|txid| txid_to_height.get(txid).cloned())
-                        .filter(|height| block_times.get(height).is_none())
-                        .take(chunk_size)
-                        .collect::<HashSet<u32>>();
+                    let needs_block_height = {
+                        let mut needs_block_height_iter = conftime_req
+                            .request()
+                            .filter_map(|txid| txid_to_height.get(txid).cloned())
+                            .filter(|height| block_times.get(height).is_none());
+                        let mut needs_block_height = HashSet::new();
+
+                        while needs_block_height.len() < chunk_size {
+                            match needs_block_height_iter.next() {
+                                Some(height) => needs_block_height.insert(height),
+                                None => break,
+                            };
+                        }
+                        needs_block_height
+                    };
 
                     let new_block_headers = self
                         .client
@@ -207,7 +202,6 @@ impl WalletSync for ElectrumBlockchain {
                     let full_details = full_transactions
                         .into_iter()
                         .map(|tx| {
-                            let mut input_index = 0usize;
                             let prev_outputs = tx
                                 .input
                                 .iter()
@@ -222,7 +216,6 @@ impl WalletSync for ElectrumBlockchain {
                                         .output
                                         .get(input.previous_output.vout as usize)
                                         .ok_or_else(electrum_goof)?;
-                                    input_index += 1;
                                     Ok(Some(txout.clone()))
                                 })
                                 .collect::<Result<Vec<_>, Error>>()?;
@@ -323,93 +316,8 @@ impl ConfigurableBlockchain for ElectrumBlockchain {
 
 #[cfg(test)]
 #[cfg(feature = "test-electrum")]
-mod test {
-    use std::sync::Arc;
-
-    use super::*;
-    use crate::database::MemoryDatabase;
-    use crate::testutils::blockchain_tests::TestClient;
-    use crate::testutils::configurable_blockchain_tests::ConfigurableBlockchainTester;
-    use crate::wallet::{AddressIndex, Wallet};
-
-    crate::bdk_blockchain_tests! {
-        fn test_instance(test_client: &TestClient) -> ElectrumBlockchain {
-            ElectrumBlockchain::from(Client::new(&test_client.electrsd.electrum_url).unwrap())
-        }
-    }
-
-    fn get_factory() -> (TestClient, Arc<ElectrumBlockchain>) {
-        let test_client = TestClient::default();
-
-        let factory = Arc::new(ElectrumBlockchain::from(
-            Client::new(&test_client.electrsd.electrum_url).unwrap(),
-        ));
-
-        (test_client, factory)
-    }
-
-    #[test]
-    fn test_electrum_blockchain_factory() {
-        let (_test_client, factory) = get_factory();
-
-        let a = factory.build("aaaaaa", None).unwrap();
-        let b = factory.build("bbbbbb", None).unwrap();
-
-        assert_eq!(
-            a.client.block_headers_subscribe().unwrap().height,
-            b.client.block_headers_subscribe().unwrap().height
-        );
-    }
-
-    #[test]
-    fn test_electrum_blockchain_factory_sync_wallet() {
-        let (mut test_client, factory) = get_factory();
-
-        let db = MemoryDatabase::new();
-        let wallet = Wallet::new(
-            "wpkh(L5EZftvrYaSudiozVRzTqLcHLNDoVn7H5HSfM9BAN6tMJX8oTWz6)",
-            None,
-            bitcoin::Network::Regtest,
-            db,
-        )
-        .unwrap();
-
-        let address = wallet.get_address(AddressIndex::New).unwrap();
-
-        let tx = testutils! {
-            @tx ( (@addr address.address) => 50_000 )
-        };
-        test_client.receive(tx);
-
-        factory
-            .sync_wallet(&wallet, None, Default::default())
-            .unwrap();
-
-        assert_eq!(wallet.get_balance().unwrap(), 50_000);
-    }
-
-    #[test]
-    fn test_electrum_with_variable_configs() {
-        struct ElectrumTester;
-
-        impl ConfigurableBlockchainTester<ElectrumBlockchain> for ElectrumTester {
-            const BLOCKCHAIN_NAME: &'static str = "Electrum";
-
-            fn config_with_stop_gap(
-                &self,
-                test_client: &mut TestClient,
-                stop_gap: usize,
-            ) -> Option<ElectrumBlockchainConfig> {
-                Some(ElectrumBlockchainConfig {
-                    url: test_client.electrsd.electrum_url.clone(),
-                    socks5: None,
-                    retry: 0,
-                    timeout: None,
-                    stop_gap: stop_gap,
-                })
-            }
-        }
-
-        ElectrumTester.run();
+crate::bdk_blockchain_tests! {
+    fn test_instance(test_client: &TestClient) -> ElectrumBlockchain {
+        ElectrumBlockchain::from(Client::new(&test_client.electrsd.electrum_url).unwrap())
     }
 }

src/blockchain/esplora/api.rs

@@ -2,7 +2,7 @@
 //!
 //! see: <https://github.com/Blockstream/esplora/blob/master/API.md>
 use crate::BlockTime;
-use bitcoin::{OutPoint, Script, Transaction, TxIn, TxOut, Txid, Witness};
+use bitcoin::{OutPoint, Script, Transaction, TxIn, TxOut, Txid};
 
 #[derive(serde::Deserialize, Clone, Debug)]
 pub struct PrevOut {
@@ -17,7 +17,7 @@ pub struct Vin {
     // None if coinbase
     pub prevout: Option<PrevOut>,
     pub scriptsig: Script,
-    #[serde(deserialize_with = "deserialize_witness", default)]
+    #[serde(deserialize_with = "deserialize_witness")]
     pub witness: Vec<Vec<u8>>,
     pub sequence: u32,
     pub is_coinbase: bool,
@@ -63,7 +63,7 @@ impl Tx {
                     },
                     script_sig: vin.scriptsig,
                     sequence: vin.sequence,
-                    witness: Witness::from_vec(vin.witness),
+                    witness: vin.witness,
                 })
                 .collect(),
             output: self

src/blockchain/esplora/mod.rs

@@ -209,38 +209,4 @@ mod test {
             "should inherit from value for 25"
         );
     }
-
-    #[test]
-    #[cfg(feature = "test-esplora")]
-    fn test_esplora_with_variable_configs() {
-        use crate::testutils::{
-            blockchain_tests::TestClient,
-            configurable_blockchain_tests::ConfigurableBlockchainTester,
-        };
-
-        struct EsploraTester;
-
-        impl ConfigurableBlockchainTester<EsploraBlockchain> for EsploraTester {
-            const BLOCKCHAIN_NAME: &'static str = "Esplora";
-
-            fn config_with_stop_gap(
-                &self,
-                test_client: &mut TestClient,
-                stop_gap: usize,
-            ) -> Option<EsploraBlockchainConfig> {
-                Some(EsploraBlockchainConfig {
-                    base_url: format!(
-                        "http://{}",
-                        test_client.electrsd.esplora_url.as_ref().unwrap()
-                    ),
-                    proxy: None,
-                    concurrency: None,
-                    stop_gap: stop_gap,
-                    timeout: None,
-                })
-            }
-        }
-
-        EsploraTester.run();
-    }
 }

src/blockchain/esplora/reqwest.rs

@@ -91,6 +91,10 @@ impl Blockchain for EsploraBlockchain {
         .collect()
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(await_or_block!(self.url_client._get_tx(txid))?)
+    }
+
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         Ok(await_or_block!(self.url_client._broadcast(tx))?)
     }
@@ -101,8 +105,6 @@ impl Blockchain for EsploraBlockchain {
     }
 }
 
-impl StatelessBlockchain for EsploraBlockchain {}
-
 #[maybe_async]
 impl GetHeight for EsploraBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
@@ -110,27 +112,12 @@ impl GetHeight for EsploraBlockchain {
     }
 }
 
-#[maybe_async]
-impl GetTx for EsploraBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(await_or_block!(self.url_client._get_tx(txid))?)
-    }
-}
-
-#[maybe_async]
-impl GetBlockHash for EsploraBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        let block_header = await_or_block!(self.url_client._get_header(height as u32))?;
-        Ok(block_header.block_hash())
-    }
-}
-
 #[maybe_async]
 impl WalletSync for EsploraBlockchain {
-    fn wallet_setup<D: BatchDatabase>(
+    fn wallet_setup<D: BatchDatabase, P: Progress>(
         &self,
         database: &mut D,
-        _progress_update: Box<dyn Progress>,
+        _progress_update: P,
     ) -> Result<(), Error> {
         use crate::blockchain::script_sync::Request;
         let mut request = script_sync::start(database, self.stop_gap)?;
@@ -203,9 +190,9 @@ impl WalletSync for EsploraBlockchain {
                         .request()
                         .map(|txid| {
                             let tx = tx_index.get(txid).expect("must be in index");
-                            Ok((tx.previous_outputs(), tx.to_tx()))
+                            (tx.previous_outputs(), tx.to_tx())
                         })
-                        .collect::<Result<_, Error>>()?;
+                        .collect();
                     tx_req.satisfy(full_txs)?
                 }
                 Request::Finish(batch_update) => break batch_update,

src/blockchain/esplora/ureq.rs

@@ -87,8 +87,12 @@ impl Blockchain for EsploraBlockchain {
         .collect()
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(self.url_client._get_tx(txid)?)
+    }
+
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        self.url_client._broadcast(tx)?;
+        let _txid = self.url_client._broadcast(tx)?;
         Ok(())
     }
 
@@ -98,27 +102,12 @@ impl Blockchain for EsploraBlockchain {
     }
 }
 
-impl StatelessBlockchain for EsploraBlockchain {}
-
 impl GetHeight for EsploraBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
         Ok(self.url_client._get_height()?)
     }
 }
 
-impl GetTx for EsploraBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.url_client._get_tx(txid)?)
-    }
-}
-
-impl GetBlockHash for EsploraBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        let block_header = self.url_client._get_header(height as u32)?;
-        Ok(block_header.block_hash())
-    }
-}
-
 impl WalletSync for EsploraBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
@@ -136,11 +125,10 @@ impl WalletSync for EsploraBlockchain {
                         .take(self.concurrency as usize)
                         .cloned();
 
-                    let mut handles = vec![];
-                    for script in scripts {
+                    let handles = scripts.map(move |script| {
                         let client = self.url_client.clone();
                         // make each request in its own thread.
-                        handles.push(std::thread::spawn(move || {
+                        std::thread::spawn(move || {
                             let mut related_txs: Vec<Tx> = client._scripthash_txs(&script, None)?;
 
                             let n_confirmed =
@@ -162,11 +150,10 @@ impl WalletSync for EsploraBlockchain {
                                 }
                             }
                             Result::<_, Error>::Ok(related_txs)
-                        }));
-                    }
+                        })
+                    });
 
                     let txs_per_script: Vec<Vec<Tx>> = handles
-                        .into_iter()
                         .map(|handle| handle.join().unwrap())
                         .collect::<Result<_, _>>()?;
                     let mut satisfaction = vec![];
@@ -201,9 +188,9 @@ impl WalletSync for EsploraBlockchain {
                         .request()
                         .map(|txid| {
                             let tx = tx_index.get(txid).expect("must be in index");
-                            Ok((tx.previous_outputs(), tx.to_tx()))
+                            (tx.previous_outputs(), tx.to_tx())
                         })
-                        .collect::<Result<_, Error>>()?;
+                        .collect();
                     tx_req.satisfy(full_txs)?
                 }
                 Request::Finish(batch_update) => break batch_update,

src/blockchain/mod.rs

@@ -21,12 +21,11 @@ use std::ops::Deref;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::Arc;
 
-use bitcoin::{BlockHash, Transaction, Txid};
+use bitcoin::{Transaction, Txid};
 
 use crate::database::BatchDatabase;
 use crate::error::Error;
-use crate::wallet::{wallet_name_from_descriptor, Wallet};
-use crate::{FeeRate, KeychainKind};
+use crate::FeeRate;
 
 #[cfg(any(
     feature = "electrum",
@@ -87,9 +86,11 @@ pub enum Capability {
 
 /// Trait that defines the actions that must be supported by a blockchain backend
 #[maybe_async]
-pub trait Blockchain: WalletSync + GetHeight + GetTx + GetBlockHash {
+pub trait Blockchain: WalletSync + GetHeight {
     /// Return the set of [`Capability`] supported by this backend
     fn get_capabilities(&self) -> HashSet<Capability>;
+    /// Fetch a transaction from the blockchain given its txid
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error>;
     /// Broadcast a transaction
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error>;
     /// Estimate the fee rate required to confirm a transaction in a given `target` of blocks
@@ -103,20 +104,6 @@ pub trait GetHeight {
     fn get_height(&self) -> Result<u32, Error>;
 }
 
-#[maybe_async]
-/// Trait for getting a transaction by txid
-pub trait GetTx {
-    /// Fetch a transaction given its txid
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error>;
-}
-
-#[maybe_async]
-/// Trait for getting block hash by block height
-pub trait GetBlockHash {
-    /// fetch block hash given its height
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error>;
-}
-
 /// Trait for blockchains that can sync by updating the database directly.
 #[maybe_async]
 pub trait WalletSync {
@@ -172,106 +159,6 @@ pub trait ConfigurableBlockchain: Blockchain + Sized {
     fn from_config(config: &Self::Config) -> Result<Self, Error>;
 }
 
-/// Trait for blockchains that don't contain any state
-///
-/// Statless blockchains can be used to sync multiple wallets with different descriptors.
-///
-/// [`BlockchainFactory`] is automatically implemented for `Arc<T>` where `T` is a stateless
-/// blockchain.
-pub trait StatelessBlockchain: Blockchain {}
-
-/// Trait for a factory of blockchains that share the underlying connection or configuration
-#[cfg_attr(
-    not(feature = "async-interface"),
-    doc = r##"
-## Example
-
-This example shows how to sync multiple walles and return the sum of their balances
-
-```no_run
-# use bdk::Error;
-# use bdk::blockchain::*;
-# use bdk::database::*;
-# use bdk::wallet::*;
-# use bdk::*;
-fn sum_of_balances<B: BlockchainFactory>(blockchain_factory: B, wallets: &[Wallet<MemoryDatabase>]) -> Result<u64, Error> {
-    Ok(wallets
-        .iter()
-        .map(|w| -> Result<_, Error> {
-            blockchain_factory.sync_wallet(&w, None, SyncOptions::default())?;
-            w.get_balance()
-        })
-        .collect::<Result<Vec<_>, _>>()?
-        .into_iter()
-        .sum())
-}
-```
-"##
-)]
-pub trait BlockchainFactory {
-    /// The type returned when building a blockchain from this factory
-    type Inner: Blockchain;
-
-    /// Build a new blockchain for the given descriptor wallet_name
-    ///
-    /// If `override_skip_blocks` is `None`, the returned blockchain will inherit the number of blocks
-    /// from the factory. Since it's not possible to override the value to `None`, set it to
-    /// `Some(0)` to rescan from the genesis.
-    fn build(
-        &self,
-        wallet_name: &str,
-        override_skip_blocks: Option<u32>,
-    ) -> Result<Self::Inner, Error>;
-
-    /// Build a new blockchain for a given wallet
-    ///
-    /// Internally uses [`wallet_name_from_descriptor`] to derive the name, and then calls
-    /// [`BlockchainFactory::build`] to create the blockchain instance.
-    fn build_for_wallet<D: BatchDatabase>(
-        &self,
-        wallet: &Wallet<D>,
-        override_skip_blocks: Option<u32>,
-    ) -> Result<Self::Inner, Error> {
-        let wallet_name = wallet_name_from_descriptor(
-            wallet.public_descriptor(KeychainKind::External)?.unwrap(),
-            wallet.public_descriptor(KeychainKind::Internal)?,
-            wallet.network(),
-            wallet.secp_ctx(),
-        )?;
-        self.build(&wallet_name, override_skip_blocks)
-    }
-
-    /// Use [`BlockchainFactory::build_for_wallet`] to get a blockchain, then sync the wallet
-    ///
-    /// This can be used when a new blockchain would only be used to sync a wallet and then
-    /// immediately dropped. Keep in mind that specific blockchain factories may perform slow
-    /// operations to build a blockchain for a given wallet, so if a wallet needs to be synced
-    /// often it's recommended to use [`BlockchainFactory::build_for_wallet`] to reuse the same
-    /// blockchain multiple times.
-    #[cfg(not(any(target_arch = "wasm32", feature = "async-interface")))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(not(any(target_arch = "wasm32", feature = "async-interface"))))
-    )]
-    fn sync_wallet<D: BatchDatabase>(
-        &self,
-        wallet: &Wallet<D>,
-        override_skip_blocks: Option<u32>,
-        sync_options: crate::wallet::SyncOptions,
-    ) -> Result<(), Error> {
-        let blockchain = self.build_for_wallet(wallet, override_skip_blocks)?;
-        wallet.sync(&blockchain, sync_options)
-    }
-}
-
-impl<T: StatelessBlockchain> BlockchainFactory for Arc<T> {
-    type Inner = Self;
-
-    fn build(&self, _wallet_name: &str, _override_skip_blocks: Option<u32>) -> Result<Self, Error> {
-        Ok(Arc::clone(self))
-    }
-}
-
 /// Data sent with a progress update over a [`channel`]
 pub type ProgressData = (f32, Option<String>);
 
@@ -343,6 +230,9 @@ impl<T: Blockchain> Blockchain for Arc<T> {
         maybe_await!(self.deref().get_capabilities())
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        maybe_await!(self.deref().get_tx(txid))
+    }
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         maybe_await!(self.deref().broadcast(tx))
     }
@@ -352,13 +242,6 @@ impl<T: Blockchain> Blockchain for Arc<T> {
     }
 }
 
-#[maybe_async]
-impl<T: GetTx> GetTx for Arc<T> {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        maybe_await!(self.deref().get_tx(txid))
-    }
-}
-
 #[maybe_async]
 impl<T: GetHeight> GetHeight for Arc<T> {
     fn get_height(&self) -> Result<u32, Error> {
@@ -366,13 +249,6 @@ impl<T: GetHeight> GetHeight for Arc<T> {
     }
 }
 
-#[maybe_async]
-impl<T: GetBlockHash> GetBlockHash for Arc<T> {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        maybe_await!(self.deref().get_block_hash(height))
-    }
-}
-
 #[maybe_async]
 impl<T: WalletSync> WalletSync for Arc<T> {
     fn wallet_setup<D: BatchDatabase>(

src/blockchain/rpc.rs

@@ -32,17 +32,17 @@
 //! ```
 
 use crate::bitcoin::consensus::deserialize;
-use crate::bitcoin::hashes::hex::ToHex;
 use crate::bitcoin::{Address, Network, OutPoint, Transaction, TxOut, Txid};
-use crate::blockchain::*;
+use crate::blockchain::{
+    Blockchain, Capability, ConfigurableBlockchain, GetHeight, Progress, WalletSync,
+};
 use crate::database::{BatchDatabase, DatabaseUtils};
-use crate::descriptor::get_checksum;
 use crate::{BlockTime, Error, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
 use bitcoincore_rpc::json::{
     GetAddressInfoResultLabel, ImportMultiOptions, ImportMultiRequest,
     ImportMultiRequestScriptPubkey, ImportMultiRescanSince,
 };
-use bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
+use bitcoincore_rpc::jsonrpc::serde_json::Value;
 use bitcoincore_rpc::Auth as RpcAuth;
 use bitcoincore_rpc::{Client, RpcApi};
 use log::debug;
@@ -56,8 +56,8 @@ use std::str::FromStr;
 pub struct RpcBlockchain {
     /// Rpc client to the node, includes the wallet name
     client: Client,
-    /// Whether the wallet is a "descriptor" or "legacy" wallet in Core
-    is_descriptors: bool,
+    /// Network used
+    network: Network,
     /// Blockchain capabilities, cached here at startup
     capabilities: HashSet<Capability>,
     /// Skip this many blocks of the blockchain at the first rescan, if None the rescan is done from the genesis block
@@ -141,6 +141,10 @@ impl Blockchain for RpcBlockchain {
         self.capabilities.clone()
     }
 
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(Some(self.client.get_raw_transaction(txid, None)?))
+    }
+
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
         Ok(self.client.send_raw_transaction(tx).map(|_| ())?)
     }
@@ -157,24 +161,12 @@ impl Blockchain for RpcBlockchain {
     }
 }
 
-impl GetTx for RpcBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(Some(self.client.get_raw_transaction(txid, None)?))
-    }
-}
-
 impl GetHeight for RpcBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
         Ok(self.client.get_blockchain_info().map(|i| i.blocks as u32)?)
     }
 }
 
-impl GetBlockHash for RpcBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        Ok(self.client.get_block_hash(height)?)
-    }
-}
-
 impl WalletSync for RpcBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
@@ -187,53 +179,22 @@ impl WalletSync for RpcBlockchain {
             "importing {} script_pubkeys (some maybe already imported)",
             scripts_pubkeys.len()
         );
-
-        if self.is_descriptors {
-            // Core still doesn't support complex descriptors like BDK, but when the wallet type is
-            // "descriptors" we should import individual addresses using `importdescriptors` rather
-            // than `importmulti`, using the `raw()` descriptor which allows us to specify an
-            // arbitrary script
-            let requests = Value::Array(
-                scripts_pubkeys
-                    .iter()
-                    .map(|s| {
-                        let desc = format!("raw({})", s.to_hex());
-                        json!({
-                            "timestamp": "now",
-                            "desc": format!("{}#{}", desc, get_checksum(&desc).unwrap()),
-                        })
-                    })
-                    .collect(),
-            );
-
-            let res: Vec<Value> = self.client.call("importdescriptors", &[requests])?;
-            res.into_iter()
-                .map(|v| match v["success"].as_bool() {
-                    Some(true) => Ok(()),
-                    Some(false) => Err(Error::Generic(
-                        v["error"]["message"]
-                            .as_str()
-                            .unwrap_or("Unknown error")
-                            .to_string(),
-                    )),
-                    _ => Err(Error::Generic("Unexpected response from Core".to_string())),
-                })
-                .collect::<Result<Vec<_>, _>>()?;
-        } else {
-            let requests: Vec<_> = scripts_pubkeys
-                .iter()
-                .map(|s| ImportMultiRequest {
-                    timestamp: ImportMultiRescanSince::Timestamp(0),
-                    script_pubkey: Some(ImportMultiRequestScriptPubkey::Script(s)),
-                    watchonly: Some(true),
-                    ..Default::default()
-                })
-                .collect();
-            let options = ImportMultiOptions {
-                rescan: Some(false),
-            };
-            self.client.import_multi(&requests, Some(&options))?;
-        }
+        let requests: Vec<_> = scripts_pubkeys
+            .iter()
+            .map(|s| ImportMultiRequest {
+                timestamp: ImportMultiRescanSince::Timestamp(0),
+                script_pubkey: Some(ImportMultiRequestScriptPubkey::Script(s)),
+                watchonly: Some(true),
+                ..Default::default()
+            })
+            .collect();
+        let options = ImportMultiOptions {
+            rescan: Some(false),
+        };
+        // Note we use import_multi because as of bitcoin core 0.21.0 many descriptors are not supported
+        // https://bitcoindevkit.org/descriptors/#compatibility-matrix
+        //TODO maybe convenient using import_descriptor for compatible descriptor and import_multi as fallback
+        self.client.import_multi(&requests, Some(&options))?;
 
         loop {
             let current_height = self.get_height()?;
@@ -288,7 +249,7 @@ impl WalletSync for RpcBlockchain {
         let mut list_txs_ids = HashSet::new();
 
         for tx_result in list_txs.iter().filter(|t| {
-            // list_txs returns all conflicting txs, we want to
+            // list_txs returns all conflicting tx we want to
             // filter out replaced tx => unconfirmed and not in the mempool
             t.info.confirmations > 0 || self.client.get_mempool_entry(&t.info.txid).is_ok()
         }) {
@@ -325,9 +286,7 @@ impl WalletSync for RpcBlockchain {
 
                 for input in tx.input.iter() {
                     if let Some(previous_output) = db.get_previous_output(&input.previous_output)? {
-                        if db.is_mine(&previous_output.script_pubkey)? {
-                            sent += previous_output.value;
-                        }
+                        sent += previous_output.value;
                     }
                 }
 
@@ -340,7 +299,8 @@ impl WalletSync for RpcBlockchain {
                     ),
                     received,
                     sent,
-                    fee: tx_result.fee.map(|f| f.as_sat().unsigned_abs()),
+                    fee: tx_result.fee.map(|f| f.as_sat().abs() as u64),
+                    verified: true,
                 };
                 debug!(
                     "saving tx: {} tx_result.fee:{:?} td.fees:{:?}",
@@ -357,37 +317,32 @@ impl WalletSync for RpcBlockchain {
             }
         }
 
-        // Filter out trasactions that are for script pubkeys that aren't in this wallet.
-        let current_utxos = current_utxo
+        let current_utxos: HashSet<_> = current_utxo
             .into_iter()
-            .filter_map(
-                |u| match db.get_path_from_script_pubkey(&u.script_pub_key) {
-                    Err(e) => Some(Err(e)),
-                    Ok(None) => None,
-                    Ok(Some(path)) => Some(Ok(LocalUtxo {
-                        outpoint: OutPoint::new(u.txid, u.vout),
-                        keychain: path.0,
-                        txout: TxOut {
-                            value: u.amount.as_sat(),
-                            script_pubkey: u.script_pub_key,
-                        },
-                        is_spent: false,
-                    })),
-                },
-            )
-            .collect::<Result<HashSet<_>, Error>>()?;
+            .map(|u| {
+                Ok(LocalUtxo {
+                    outpoint: OutPoint::new(u.txid, u.vout),
+                    keychain: db
+                        .get_path_from_script_pubkey(&u.script_pub_key)?
+                        .ok_or(Error::TransactionNotFound)?
+                        .0,
+                    txout: TxOut {
+                        value: u.amount.as_sat(),
+                        script_pubkey: u.script_pub_key,
+                    },
+                })
+            })
+            .collect::<Result<_, Error>>()?;
 
         let spent: HashSet<_> = known_utxos.difference(&current_utxos).collect();
-        for utxo in spent {
-            debug!("setting as spent utxo: {:?}", utxo);
-            let mut spent_utxo = utxo.clone();
-            spent_utxo.is_spent = true;
-            db.set_utxo(&spent_utxo)?;
+        for s in spent {
+            debug!("removing utxo: {:?}", s);
+            db.del_utxo(&s.outpoint)?;
         }
         let received: HashSet<_> = current_utxos.difference(&known_utxos).collect();
-        for utxo in received {
-            debug!("adding utxo: {:?}", utxo);
-            db.set_utxo(utxo)?;
+        for s in received {
+            debug!("adding utxo: {:?}", s);
+            db.set_utxo(s)?;
         }
 
         for (keykind, index) in indexes {
@@ -410,36 +365,20 @@ impl ConfigurableBlockchain for RpcBlockchain {
         debug!("connecting to {} auth:{:?}", wallet_url, config.auth);
 
         let client = Client::new(wallet_url.as_str(), config.auth.clone().into())?;
-        let rpc_version = client.version()?;
-
         let loaded_wallets = client.list_wallets()?;
         if loaded_wallets.contains(&wallet_name) {
             debug!("wallet already loaded {:?}", wallet_name);
-        } else if list_wallet_dir(&client)?.contains(&wallet_name) {
-            client.load_wallet(&wallet_name)?;
-            debug!("wallet loaded {:?}", wallet_name);
         } else {
-            // pre-0.21 use legacy wallets
-            if rpc_version < 210_000 {
-                client.create_wallet(&wallet_name, Some(true), None, None, None)?;
+            let existing_wallets = list_wallet_dir(&client)?;
+            if existing_wallets.contains(&wallet_name) {
+                client.load_wallet(&wallet_name)?;
+                debug!("wallet loaded {:?}", wallet_name);
             } else {
-                // TODO: move back to api call when https://github.com/rust-bitcoin/rust-bitcoincore-rpc/issues/225 is closed
-                let args = [
-                    Value::String(wallet_name.clone()),
-                    Value::Bool(true),
-                    Value::Bool(false),
-                    Value::Null,
-                    Value::Bool(false),
-                    Value::Bool(true),
-                ];
-                let _: Value = client.call("createwallet", &args)?;
+                client.create_wallet(&wallet_name, Some(true), None, None, None)?;
+                debug!("wallet created {:?}", wallet_name);
             }
-
-            debug!("wallet created {:?}", wallet_name);
         }
 
-        let is_descriptors = is_wallet_descriptor(&client)?;
-
         let blockchain_info = client.get_blockchain_info()?;
         let network = match blockchain_info.chain.as_str() {
             "main" => Network::Bitcoin,
@@ -456,6 +395,7 @@ impl ConfigurableBlockchain for RpcBlockchain {
         }
 
         let mut capabilities: HashSet<_> = vec![Capability::FullHistory].into_iter().collect();
+        let rpc_version = client.version()?;
         if rpc_version >= 210_000 {
             let info: HashMap<String, Value> = client.call("getindexinfo", &[]).unwrap();
             if info.contains_key("txindex") {
@@ -471,8 +411,8 @@ impl ConfigurableBlockchain for RpcBlockchain {
 
         Ok(RpcBlockchain {
             client,
+            network,
             capabilities,
-            is_descriptors,
             _storage_address: storage_address,
             skip_blocks: config.skip_blocks,
         })
@@ -495,141 +435,18 @@ fn list_wallet_dir(client: &Client) -> Result<Vec<String>, Error> {
     Ok(result.wallets.into_iter().map(|n| n.name).collect())
 }
 
-/// Returns whether a wallet is legacy or descriptors by calling `getwalletinfo`.
-///
-/// This API is mapped by bitcoincore_rpc, but it doesn't have the fields we need (either
-/// "descriptors" or "format") so we have to call the RPC manually
-fn is_wallet_descriptor(client: &Client) -> Result<bool, Error> {
-    #[derive(Deserialize)]
-    struct CallResult {
-        descriptors: Option<bool>,
-    }
-
-    let result: CallResult = client.call("getwalletinfo", &[])?;
-    Ok(result.descriptors.unwrap_or(false))
-}
-
-/// Factory of [`RpcBlockchain`] instances, implements [`BlockchainFactory`]
-///
-/// Internally caches the node url and authentication params and allows getting many different [`RpcBlockchain`]
-/// objects for different wallet names and with different rescan heights.
-///
-/// ## Example
-///
-/// ```no_run
-/// # use bdk::bitcoin::Network;
-/// # use bdk::blockchain::BlockchainFactory;
-/// # use bdk::blockchain::rpc::{Auth, RpcBlockchainFactory};
-/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let factory = RpcBlockchainFactory {
-///     url: "http://127.0.0.1:18332".to_string(),
-///     auth: Auth::Cookie {
-///         file: "/home/user/.bitcoin/.cookie".into(),
-///     },
-///     network: Network::Testnet,
-///     wallet_name_prefix: Some("prefix-".to_string()),
-///     default_skip_blocks: 100_000,
-/// };
-/// let main_wallet_blockchain = factory.build("main_wallet", Some(200_000))?;
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug, Clone)]
-pub struct RpcBlockchainFactory {
-    /// The bitcoin node url
-    pub url: String,
-    /// The bitcoin node authentication mechanism
-    pub auth: Auth,
-    /// The network we are using (it will be checked the bitcoin node network matches this)
-    pub network: Network,
-    /// The optional prefix used to build the full wallet name for blockchains
-    pub wallet_name_prefix: Option<String>,
-    /// Default number of blocks to skip which will be inherited by blockchain unless overridden
-    pub default_skip_blocks: u32,
-}
-
-impl BlockchainFactory for RpcBlockchainFactory {
-    type Inner = RpcBlockchain;
-
-    fn build(
-        &self,
-        checksum: &str,
-        override_skip_blocks: Option<u32>,
-    ) -> Result<Self::Inner, Error> {
-        RpcBlockchain::from_config(&RpcConfig {
-            url: self.url.clone(),
-            auth: self.auth.clone(),
-            network: self.network,
-            wallet_name: format!(
-                "{}{}",
-                self.wallet_name_prefix.as_ref().unwrap_or(&String::new()),
-                checksum
-            ),
-            skip_blocks: Some(override_skip_blocks.unwrap_or(self.default_skip_blocks)),
-        })
-    }
-}
-
 #[cfg(test)]
-#[cfg(any(feature = "test-rpc", feature = "test-rpc-legacy"))]
-mod test {
-    use super::*;
-    use crate::testutils::blockchain_tests::TestClient;
+#[cfg(feature = "test-rpc")]
+crate::bdk_blockchain_tests! {
 
-    use bitcoin::Network;
-    use bitcoincore_rpc::RpcApi;
-
-    crate::bdk_blockchain_tests! {
-        fn test_instance(test_client: &TestClient) -> RpcBlockchain {
-            let config = RpcConfig {
-                url: test_client.bitcoind.rpc_url(),
-                auth: Auth::Cookie { file: test_client.bitcoind.params.cookie_file.clone() },
-                network: Network::Regtest,
-                wallet_name: format!("client-wallet-test-{}", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() ),
-                skip_blocks: None,
-            };
-            RpcBlockchain::from_config(&config).unwrap()
-        }
-    }
-
-    fn get_factory() -> (TestClient, RpcBlockchainFactory) {
-        let test_client = TestClient::default();
-
-        let factory = RpcBlockchainFactory {
+    fn test_instance(test_client: &TestClient) -> RpcBlockchain {
+        let config = RpcConfig {
             url: test_client.bitcoind.rpc_url(),
-            auth: Auth::Cookie {
-                file: test_client.bitcoind.params.cookie_file.clone(),
-            },
+            auth: Auth::Cookie { file: test_client.bitcoind.params.cookie_file.clone() },
             network: Network::Regtest,
-            wallet_name_prefix: Some("prefix-".into()),
-            default_skip_blocks: 0,
+            wallet_name: format!("client-wallet-test-{:?}", std::time::SystemTime::now() ),
+            skip_blocks: None,
         };
-
-        (test_client, factory)
-    }
-
-    #[test]
-    fn test_rpc_blockchain_factory() {
-        let (_test_client, factory) = get_factory();
-
-        let a = factory.build("aaaaaa", None).unwrap();
-        assert_eq!(a.skip_blocks, Some(0));
-        assert_eq!(
-            a.client
-                .get_wallet_info()
-                .expect("Node connection isn't working")
-                .wallet_name,
-            "prefix-aaaaaa"
-        );
-
-        let b = factory.build("bbbbbb", Some(100)).unwrap();
-        assert_eq!(b.skip_blocks, Some(100));
-        assert_eq!(
-            b.client
-                .get_wallet_info()
-                .expect("Node connection isn't working")
-                .wallet_name,
-            "prefix-bbbbbb"
-        );
+        RpcBlockchain::from_config(&config).unwrap()
     }
 }

src/blockchain/script_sync.rs

@@ -178,9 +178,7 @@ impl<'a, D: BatchDatabase> TxReq<'a, D> {
                 let mut inputs_sum: u64 = 0;
                 let mut outputs_sum: u64 = 0;
 
-                for (txout, (_input_index, input)) in
-                    vout.into_iter().zip(tx.input.iter().enumerate())
-                {
+                for (txout, input) in vout.into_iter().zip(tx.input.iter()) {
                     let txout = match txout {
                         Some(txout) => txout,
                         None => {
@@ -192,19 +190,7 @@ impl<'a, D: BatchDatabase> TxReq<'a, D> {
                             continue;
                         }
                     };
-                    // Verify this input if requested via feature flag
-                    #[cfg(feature = "verify")]
-                    {
-                        use crate::wallet::verify::VerifyError;
-                        let serialized_tx = bitcoin::consensus::serialize(&tx);
-                        bitcoinconsensus::verify(
-                            txout.script_pubkey.to_bytes().as_ref(),
-                            txout.value,
-                            &serialized_tx,
-                            _input_index,
-                        )
-                        .map_err(VerifyError::from)?;
-                    }
+
                     inputs_sum += txout.value;
                     if self.state.db.is_mine(&txout.script_pubkey)? {
                         sent += txout.value;
@@ -228,6 +214,7 @@ impl<'a, D: BatchDatabase> TxReq<'a, D> {
                     // we're going to fill this in later
                     confirmation_time: None,
                     fee: Some(fee),
+                    verified: false,
                 })
             })
             .collect::<Result<Vec<_>, _>>()?;
@@ -314,22 +301,6 @@ impl<'a, D: BatchDatabase> State<'a, D> {
         let finished_txs = make_txs_consistent(&self.finished_txs);
         let observed_txids: HashSet<Txid> = finished_txs.iter().map(|tx| tx.txid).collect();
         let txids_to_delete = existing_txids.difference(&observed_txids);
-
-        // Ensure `last_active_index` does not decrement database's current state.
-        let index_updates = self
-            .last_active_index
-            .iter()
-            .map(|(keychain, sync_index)| {
-                let sync_index = *sync_index as u32;
-                let index_res = match self.db.get_last_index(*keychain) {
-                    Ok(Some(db_index)) => Ok(std::cmp::max(db_index, sync_index)),
-                    Ok(None) => Ok(sync_index),
-                    Err(err) => Err(err),
-                };
-                index_res.map(|index| (*keychain, index))
-            })
-            .collect::<Result<Vec<(KeychainKind, u32)>, _>>()?;
-
         let mut batch = self.db.begin_batch();
 
         // Delete old txs that no longer exist
@@ -348,23 +319,7 @@ impl<'a, D: BatchDatabase> State<'a, D> {
             batch.del_tx(txid, true)?;
         }
 
-        let mut spent_utxos = HashSet::new();
-
-        // track all the spent utxos
-        for finished_tx in &finished_txs {
-            let tx = finished_tx
-                .transaction
-                .as_ref()
-                .expect("transaction will always be present here");
-            for input in &tx.input {
-                spent_utxos.insert(&input.previous_output);
-            }
-        }
-
-        // set every utxo we observed, unless it's already spent
-        // we don't do this in the loop above as we want to know all the spent outputs before
-        // adding the non-spent to the batch in case there are new tranasactions
-        // that spend form each other.
+        // Set every tx we observed
         for finished_tx in &finished_txs {
             let tx = finished_tx
                 .transaction
@@ -375,28 +330,34 @@ impl<'a, D: BatchDatabase> State<'a, D> {
                     self.db.get_path_from_script_pubkey(&output.script_pubkey)?
                 {
                     // add utxos we own from the new transactions we've seen.
-                    let outpoint = OutPoint {
-                        txid: finished_tx.txid,
-                        vout: i as u32,
-                    };
-
                     batch.set_utxo(&LocalUtxo {
-                        outpoint,
+                        outpoint: OutPoint {
+                            txid: finished_tx.txid,
+                            vout: i as u32,
+                        },
                         txout: output.clone(),
                         keychain,
-                        // Is this UTXO in the spent_utxos set?
-                        is_spent: spent_utxos.get(&outpoint).is_some(),
                     })?;
                 }
             }
-
             batch.set_tx(finished_tx)?;
         }
 
-        // apply index updates
-        for (keychain, new_index) in index_updates {
-            debug!("updating index ({}, {})", keychain.as_byte(), new_index);
-            batch.set_last_index(keychain, new_index)?;
+        // we don't do this in the loop above since we may want to delete some of the utxos we
+        // just added in case there are new tranasactions that spend form each other.
+        for finished_tx in &finished_txs {
+            let tx = finished_tx
+                .transaction
+                .as_ref()
+                .expect("transaction will always be present here");
+            for input in &tx.input {
+                // Delete any spent utxos
+                batch.del_utxo(&input.previous_output)?;
+            }
+        }
+
+        for (keychain, last_active_index) in self.last_active_index {
+            batch.set_last_index(keychain, last_active_index as u32)?;
         }
 
         info!(

src/database/any.rs

@@ -61,7 +61,6 @@ macro_rules! impl_from {
 
 macro_rules! impl_inner_method {
     ( $enum_name:ident, $self:expr, $name:ident $(, $args:expr)* ) => {
-        #[allow(deprecated)]
         match $self {
             $enum_name::Memory(inner) => inner.$name( $($args, )* ),
             #[cfg(feature = "key-value-db")]
@@ -255,6 +254,10 @@ impl Database for AnyDatabase {
     fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
         impl_inner_method!(AnyDatabase, self, increment_last_index, keychain)
     }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        impl_inner_method!(AnyDatabase, self, flush)
+    }
 }
 
 impl BatchOperations for AnyBatch {

src/database/keyvalue.rs

@@ -43,7 +43,6 @@ macro_rules! impl_batch_operations {
             let value = json!({
                 "t": utxo.txout,
                 "i": utxo.keychain,
-                "s": utxo.is_spent,
             });
             self.insert(key, serde_json::to_vec(&value)?)$($after_insert)*;
 
@@ -126,9 +125,8 @@ macro_rules! impl_batch_operations {
                     let mut val: serde_json::Value = serde_json::from_slice(&b)?;
                     let txout = serde_json::from_value(val["t"].take())?;
                     let keychain = serde_json::from_value(val["i"].take())?;
-                    let is_spent = val.get_mut("s").and_then(|s| s.take().as_bool()).unwrap_or(false);
 
-                    Ok(Some(LocalUtxo { outpoint: outpoint.clone(), txout, keychain, is_spent, }))
+                    Ok(Some(LocalUtxo { outpoint: outpoint.clone(), txout, keychain }))
                 }
             }
         }
@@ -166,9 +164,16 @@ macro_rules! impl_batch_operations {
         fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
             let key = MapKey::LastIndex(keychain).as_map_key();
             let res = self.remove(key);
-            $process_delete!(res)
-            .map(ivec_to_u32)
-            .transpose()
+            let res = $process_delete!(res);
+
+            match res {
+                None => Ok(None),
+                Some(b) => {
+                    let array: [u8; 4] = b.as_ref().try_into().map_err(|_| Error::InvalidU32Bytes(b.to_vec()))?;
+                    let val = u32::from_be_bytes(array);
+                    Ok(Some(val))
+                }
+            }
         }
 
         fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
@@ -241,16 +246,11 @@ impl Database for Tree {
                 let mut val: serde_json::Value = serde_json::from_slice(&v)?;
                 let txout = serde_json::from_value(val["t"].take())?;
                 let keychain = serde_json::from_value(val["i"].take())?;
-                let is_spent = val
-                    .get_mut("s")
-                    .and_then(|s| s.take().as_bool())
-                    .unwrap_or(false);
 
                 Ok(LocalUtxo {
                     outpoint,
                     txout,
                     keychain,
-                    is_spent,
                 })
             })
             .collect()
@@ -314,16 +314,11 @@ impl Database for Tree {
                 let mut val: serde_json::Value = serde_json::from_slice(&b)?;
                 let txout = serde_json::from_value(val["t"].take())?;
                 let keychain = serde_json::from_value(val["i"].take())?;
-                let is_spent = val
-                    .get_mut("s")
-                    .and_then(|s| s.take().as_bool())
-                    .unwrap_or(false);
 
                 Ok(LocalUtxo {
                     outpoint: *outpoint,
                     txout,
                     keychain,
-                    is_spent,
                 })
             })
             .transpose()
@@ -350,7 +345,16 @@ impl Database for Tree {
 
     fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
         let key = MapKey::LastIndex(keychain).as_map_key();
-        self.get(key)?.map(ivec_to_u32).transpose()
+        self.get(key)?
+            .map(|b| -> Result<_, Error> {
+                let array: [u8; 4] = b
+                    .as_ref()
+                    .try_into()
+                    .map_err(|_| Error::InvalidU32Bytes(b.to_vec()))?;
+                let val = u32::from_be_bytes(array);
+                Ok(val)
+            })
+            .transpose()
     }
 
     fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {
@@ -377,17 +381,19 @@ impl Database for Tree {
 
             Some(new.to_be_bytes().to_vec())
         })?
-        .map_or(Ok(0), ivec_to_u32)
+        .map_or(Ok(0), |b| -> Result<_, Error> {
+            let array: [u8; 4] = b
+                .as_ref()
+                .try_into()
+                .map_err(|_| Error::InvalidU32Bytes(b.to_vec()))?;
+            let val = u32::from_be_bytes(array);
+            Ok(val)
+        })
     }
-}
 
-fn ivec_to_u32(b: sled::IVec) -> Result<u32, Error> {
-    let array: [u8; 4] = b
-        .as_ref()
-        .try_into()
-        .map_err(|_| Error::InvalidU32Bytes(b.to_vec()))?;
-    let val = u32::from_be_bytes(array);
-    Ok(val)
+    fn flush(&mut self) -> Result<(), Error> {
+        Ok(Tree::flush(self).map(|_| ())?)
+    }
 }
 
 impl BatchDatabase for Tree {

src/database/memory.rs

@@ -150,10 +150,8 @@ impl BatchOperations for MemoryDatabase {
 
     fn set_utxo(&mut self, utxo: &LocalUtxo) -> Result<(), Error> {
         let key = MapKey::Utxo(Some(&utxo.outpoint)).as_map_key();
-        self.map.insert(
-            key,
-            Box::new((utxo.txout.clone(), utxo.keychain, utxo.is_spent)),
-        );
+        self.map
+            .insert(key, Box::new((utxo.txout.clone(), utxo.keychain)));
 
         Ok(())
     }
@@ -230,12 +228,11 @@ impl BatchOperations for MemoryDatabase {
         match res {
             None => Ok(None),
             Some(b) => {
-                let (txout, keychain, is_spent) = b.downcast_ref().cloned().unwrap();
+                let (txout, keychain) = b.downcast_ref().cloned().unwrap();
                 Ok(Some(LocalUtxo {
                     outpoint: *outpoint,
                     txout,
                     keychain,
-                    is_spent,
                 }))
             }
         }
@@ -329,12 +326,11 @@ impl Database for MemoryDatabase {
             .range::<Vec<u8>, _>((Included(&key), Excluded(&after(&key))))
             .map(|(k, v)| {
                 let outpoint = deserialize(&k[1..]).unwrap();
-                let (txout, keychain, is_spent) = v.downcast_ref().cloned().unwrap();
+                let (txout, keychain) = v.downcast_ref().cloned().unwrap();
                 Ok(LocalUtxo {
                     outpoint,
                     txout,
                     keychain,
-                    is_spent,
                 })
             })
             .collect()
@@ -393,12 +389,11 @@ impl Database for MemoryDatabase {
     fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
         let key = MapKey::Utxo(Some(outpoint)).as_map_key();
         Ok(self.map.get(&key).map(|b| {
-            let (txout, keychain, is_spent) = b.downcast_ref().cloned().unwrap();
+            let (txout, keychain) = b.downcast_ref().cloned().unwrap();
             LocalUtxo {
                 outpoint: *outpoint,
                 txout,
                 keychain,
-                is_spent,
             }
         }))
     }
@@ -449,6 +444,10 @@ impl Database for MemoryDatabase {
 
         Ok(*value)
     }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
 }
 
 impl BatchDatabase for MemoryDatabase {
@@ -482,23 +481,15 @@ impl ConfigurableDatabase for MemoryDatabase {
 /// don't have `test` set.
 macro_rules! populate_test_db {
     ($db:expr, $tx_meta:expr, $current_height:expr$(,)?) => {{
-        $crate::populate_test_db!($db, $tx_meta, $current_height, (@coinbase false))
-    }};
-    ($db:expr, $tx_meta:expr, $current_height:expr, (@coinbase $is_coinbase:expr)$(,)?) => {{
         use std::str::FromStr;
         use $crate::database::BatchOperations;
         let mut db = $db;
         let tx_meta = $tx_meta;
         let current_height: Option<u32> = $current_height;
-        let input = if $is_coinbase {
-            vec![$crate::bitcoin::TxIn::default()]
-        } else {
-            vec![]
-        };
         let tx = $crate::bitcoin::Transaction {
             version: 1,
             lock_time: 0,
-            input,
+            input: vec![],
             output: tx_meta
                 .output
                 .iter()
@@ -512,13 +503,10 @@ macro_rules! populate_test_db {
         };
 
         let txid = tx.txid();
-        let confirmation_time = tx_meta
-            .min_confirmations
-            .and_then(|v| if v == 0 { None } else { Some(v) })
-            .map(|conf| $crate::BlockTime {
-                height: current_height.unwrap().checked_sub(conf as u32).unwrap() + 1,
-                timestamp: 0,
-            });
+        let confirmation_time = tx_meta.min_confirmations.map(|conf| $crate::BlockTime {
+            height: current_height.unwrap().checked_sub(conf as u32).unwrap(),
+            timestamp: 0,
+        });
 
         let tx_details = $crate::TransactionDetails {
             transaction: Some(tx.clone()),
@@ -527,6 +515,7 @@ macro_rules! populate_test_db {
             received: 0,
             sent: 0,
             confirmation_time,
+            verified: current_height.is_some(),
         };
 
         db.set_tx(&tx_details).unwrap();
@@ -538,7 +527,6 @@ macro_rules! populate_test_db {
                     vout: vout as u32,
                 },
                 keychain: $crate::KeychainKind::External,
-                is_spent: false,
             })
             .unwrap();
         }

src/database/mod.rs

@@ -158,6 +158,9 @@ pub trait Database: BatchOperations {
     ///
     /// It should insert and return `0` if not present in the database
     fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error>;
+
+    /// Force changes to be written to disk
+    fn flush(&mut self) -> Result<(), Error>;
 }
 
 /// Trait for a database that supports batch operations
@@ -193,7 +196,8 @@ pub(crate) trait DatabaseUtils: Database {
         D: FnOnce() -> Result<Option<Transaction>, Error>,
     {
         self.get_tx(txid, true)?
-            .and_then(|t| t.transaction)
+            .map(|t| t.transaction)
+            .flatten()
             .map_or_else(default, |t| Ok(Some(t)))
     }
 
@@ -312,12 +316,10 @@ pub mod test {
             txout,
             outpoint,
             keychain: KeychainKind::External,
-            is_spent: true,
         };
 
         tree.set_utxo(&utxo).unwrap();
-        tree.set_utxo(&utxo).unwrap();
-        assert_eq!(tree.iter_utxos().unwrap().len(), 1);
+
         assert_eq!(tree.get_utxo(&outpoint).unwrap(), Some(utxo));
     }
 
@@ -346,6 +348,7 @@ pub mod test {
                 timestamp: 123456,
                 height: 1000,
             }),
+            verified: true,
         };
 
         tree.set_tx(&tx_details).unwrap();
@@ -369,34 +372,6 @@ pub mod test {
         );
     }
 
-    pub fn test_list_transaction<D: Database>(mut tree: D) {
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-        let txid = tx.txid();
-        let mut tx_details = TransactionDetails {
-            transaction: Some(tx),
-            txid,
-            received: 1337,
-            sent: 420420,
-            fee: Some(140),
-            confirmation_time: Some(BlockTime {
-                timestamp: 123456,
-                height: 1000,
-            }),
-        };
-
-        tree.set_tx(&tx_details).unwrap();
-
-        // get raw tx
-        assert_eq!(tree.iter_txs(true).unwrap(), vec![tx_details.clone()]);
-
-        // now get without raw tx
-        tx_details.transaction = None;
-
-        // get not raw tx
-        assert_eq!(tree.iter_txs(false).unwrap(), vec![tx_details.clone()]);
-    }
-
     pub fn test_last_index<D: Database>(mut tree: D) {
         tree.set_last_index(KeychainKind::External, 1337).unwrap();
 

src/database/sqlite.rs

@@ -35,22 +35,7 @@ static MIGRATIONS: &[&str] = &[
     "CREATE UNIQUE INDEX idx_indices_keychain ON last_derivation_indices(keychain);",
     "CREATE TABLE checksums (keychain TEXT, checksum BLOB);",
     "CREATE INDEX idx_checksums_keychain ON checksums(keychain);",
-    "CREATE TABLE sync_time (id INTEGER PRIMARY KEY, height INTEGER, timestamp INTEGER);",
-    "ALTER TABLE transaction_details RENAME TO transaction_details_old;",
-    "CREATE TABLE transaction_details (txid BLOB, timestamp INTEGER, received INTEGER, sent INTEGER, fee INTEGER, height INTEGER);",
-    "INSERT INTO transaction_details SELECT txid, timestamp, received, sent, fee, height FROM transaction_details_old;",
-    "DROP TABLE transaction_details_old;",
-    "ALTER TABLE utxos ADD COLUMN is_spent;",
-    // drop all data due to possible inconsistencies with duplicate utxos, re-sync required
-    "DELETE FROM checksums;",
-    "DELETE FROM last_derivation_indices;",
-    "DELETE FROM script_pubkeys;",
-    "DELETE FROM sync_time;",
-    "DELETE FROM transaction_details;",
-    "DELETE FROM transactions;",
-    "DELETE FROM utxos;",
-    "DROP INDEX idx_txid_vout;",
-    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);"
+    "CREATE TABLE sync_time (id INTEGER PRIMARY KEY, height INTEGER, timestamp INTEGER);"
 ];
 
 /// Sqlite database stored on filesystem
@@ -94,16 +79,14 @@ impl SqliteDatabase {
         vout: u32,
         txid: &[u8],
         script: &[u8],
-        is_spent: bool,
     ) -> Result<i64, Error> {
-        let mut statement = self.connection.prepare_cached("INSERT INTO utxos (value, keychain, vout, txid, script, is_spent) VALUES (:value, :keychain, :vout, :txid, :script, :is_spent) ON CONFLICT(txid, vout) DO UPDATE SET value=:value, keychain=:keychain, script=:script, is_spent=:is_spent")?;
+        let mut statement = self.connection.prepare_cached("INSERT INTO utxos (value, keychain, vout, txid, script) VALUES (:value, :keychain, :vout, :txid, :script)")?;
         statement.execute(named_params! {
             ":value": value,
             ":keychain": keychain,
             ":vout": vout,
             ":txid": txid,
-            ":script": script,
-            ":is_spent": is_spent,
+            ":script": script
         })?;
 
         Ok(self.connection.last_insert_rowid())
@@ -144,7 +127,7 @@ impl SqliteDatabase {
 
         let txid: &[u8] = &transaction.txid;
 
-        let mut statement = self.connection.prepare_cached("INSERT INTO transaction_details (txid, timestamp, received, sent, fee, height) VALUES (:txid, :timestamp, :received, :sent, :fee, :height)")?;
+        let mut statement = self.connection.prepare_cached("INSERT INTO transaction_details (txid, timestamp, received, sent, fee, height, verified) VALUES (:txid, :timestamp, :received, :sent, :fee, :height, :verified)")?;
 
         statement.execute(named_params! {
             ":txid": txid,
@@ -153,6 +136,7 @@ impl SqliteDatabase {
             ":sent": transaction.sent,
             ":fee": transaction.fee,
             ":height": height,
+            ":verified": transaction.verified
         })?;
 
         Ok(self.connection.last_insert_rowid())
@@ -169,7 +153,7 @@ impl SqliteDatabase {
 
         let txid: &[u8] = &transaction.txid;
 
-        let mut statement = self.connection.prepare_cached("UPDATE transaction_details SET timestamp=:timestamp, received=:received, sent=:sent, fee=:fee, height=:height WHERE txid=:txid")?;
+        let mut statement = self.connection.prepare_cached("UPDATE transaction_details SET timestamp=:timestamp, received=:received, sent=:sent, fee=:fee, height=:height, verified=:verified WHERE txid=:txid")?;
 
         statement.execute(named_params! {
             ":txid": txid,
@@ -178,6 +162,7 @@ impl SqliteDatabase {
             ":sent": transaction.sent,
             ":fee": transaction.fee,
             ":height": height,
+            ":verified": transaction.verified,
         })?;
 
         Ok(())
@@ -304,7 +289,7 @@ impl SqliteDatabase {
     fn select_utxos(&self) -> Result<Vec<LocalUtxo>, Error> {
         let mut statement = self
             .connection
-            .prepare_cached("SELECT value, keychain, vout, txid, script, is_spent FROM utxos")?;
+            .prepare_cached("SELECT value, keychain, vout, txid, script FROM utxos")?;
         let mut utxos: Vec<LocalUtxo> = vec![];
         let mut rows = statement.query([])?;
         while let Some(row) = rows.next()? {
@@ -313,7 +298,6 @@ impl SqliteDatabase {
             let vout = row.get(2)?;
             let txid: Vec<u8> = row.get(3)?;
             let script: Vec<u8> = row.get(4)?;
-            let is_spent: bool = row.get(5)?;
 
             let keychain: KeychainKind = serde_json::from_str(&keychain)?;
 
@@ -324,16 +308,19 @@ impl SqliteDatabase {
                     script_pubkey: script.into(),
                 },
                 keychain,
-                is_spent,
             })
         }
 
         Ok(utxos)
     }
 
-    fn select_utxo_by_outpoint(&self, txid: &[u8], vout: u32) -> Result<Option<LocalUtxo>, Error> {
+    fn select_utxo_by_outpoint(
+        &self,
+        txid: &[u8],
+        vout: u32,
+    ) -> Result<Option<(u64, KeychainKind, Script)>, Error> {
         let mut statement = self.connection.prepare_cached(
-            "SELECT value, keychain, script, is_spent FROM utxos WHERE txid=:txid AND vout=:vout",
+            "SELECT value, keychain, script FROM utxos WHERE txid=:txid AND vout=:vout",
         )?;
         let mut rows = statement.query(named_params! {":txid": txid,":vout": vout})?;
         match rows.next()? {
@@ -342,18 +329,9 @@ impl SqliteDatabase {
                 let keychain: String = row.get(1)?;
                 let keychain: KeychainKind = serde_json::from_str(&keychain)?;
                 let script: Vec<u8> = row.get(2)?;
-                let script_pubkey: Script = script.into();
-                let is_spent: bool = row.get(3)?;
+                let script: Script = script.into();
 
-                Ok(Some(LocalUtxo {
-                    outpoint: OutPoint::new(deserialize(txid)?, vout),
-                    txout: TxOut {
-                        value,
-                        script_pubkey,
-                    },
-                    keychain,
-                    is_spent,
-                }))
+                Ok(Some((value, keychain, script)))
             }
             None => Ok(None),
         }
@@ -389,7 +367,7 @@ impl SqliteDatabase {
     }
 
     fn select_transaction_details_with_raw(&self) -> Result<Vec<TransactionDetails>, Error> {
-        let mut statement = self.connection.prepare_cached("SELECT transaction_details.txid, transaction_details.timestamp, transaction_details.received, transaction_details.sent, transaction_details.fee, transaction_details.height, transactions.raw_tx FROM transaction_details, transactions WHERE transaction_details.txid = transactions.txid")?;
+        let mut statement = self.connection.prepare_cached("SELECT transaction_details.txid, transaction_details.timestamp, transaction_details.received, transaction_details.sent, transaction_details.fee, transaction_details.height, transaction_details.verified, transactions.raw_tx FROM transaction_details, transactions WHERE transaction_details.txid = transactions.txid")?;
         let mut transaction_details: Vec<TransactionDetails> = vec![];
         let mut rows = statement.query([])?;
         while let Some(row) = rows.next()? {
@@ -400,7 +378,8 @@ impl SqliteDatabase {
             let sent: u64 = row.get(3)?;
             let fee: Option<u64> = row.get(4)?;
             let height: Option<u32> = row.get(5)?;
-            let raw_tx: Option<Vec<u8>> = row.get(6)?;
+            let verified: bool = row.get(6)?;
+            let raw_tx: Option<Vec<u8>> = row.get(7)?;
             let tx: Option<Transaction> = match raw_tx {
                 Some(raw_tx) => {
                     let tx: Transaction = deserialize(&raw_tx)?;
@@ -421,6 +400,7 @@ impl SqliteDatabase {
                 sent,
                 fee,
                 confirmation_time,
+                verified,
             });
         }
         Ok(transaction_details)
@@ -428,7 +408,7 @@ impl SqliteDatabase {
 
     fn select_transaction_details(&self) -> Result<Vec<TransactionDetails>, Error> {
         let mut statement = self.connection.prepare_cached(
-            "SELECT txid, timestamp, received, sent, fee, height FROM transaction_details",
+            "SELECT txid, timestamp, received, sent, fee, height, verified FROM transaction_details",
         )?;
         let mut transaction_details: Vec<TransactionDetails> = vec![];
         let mut rows = statement.query([])?;
@@ -440,6 +420,7 @@ impl SqliteDatabase {
             let sent: u64 = row.get(3)?;
             let fee: Option<u64> = row.get(4)?;
             let height: Option<u32> = row.get(5)?;
+            let verified: bool = row.get(6)?;
 
             let confirmation_time = match (height, timestamp) {
                 (Some(height), Some(timestamp)) => Some(BlockTime { height, timestamp }),
@@ -453,6 +434,7 @@ impl SqliteDatabase {
                 sent,
                 fee,
                 confirmation_time,
+                verified,
             });
         }
         Ok(transaction_details)
@@ -462,7 +444,7 @@ impl SqliteDatabase {
         &self,
         txid: &[u8],
     ) -> Result<Option<TransactionDetails>, Error> {
-        let mut statement = self.connection.prepare_cached("SELECT transaction_details.timestamp, transaction_details.received, transaction_details.sent, transaction_details.fee, transaction_details.height, transactions.raw_tx FROM transaction_details, transactions WHERE transaction_details.txid=transactions.txid AND transaction_details.txid=:txid")?;
+        let mut statement = self.connection.prepare_cached("SELECT transaction_details.timestamp, transaction_details.received, transaction_details.sent, transaction_details.fee, transaction_details.height, transaction_details.verified, transactions.raw_tx FROM transaction_details, transactions WHERE transaction_details.txid=transactions.txid AND transaction_details.txid=:txid")?;
         let mut rows = statement.query(named_params! { ":txid": txid })?;
 
         match rows.next()? {
@@ -472,8 +454,9 @@ impl SqliteDatabase {
                 let sent: u64 = row.get(2)?;
                 let fee: Option<u64> = row.get(3)?;
                 let height: Option<u32> = row.get(4)?;
+                let verified: bool = row.get(5)?;
 
-                let raw_tx: Option<Vec<u8>> = row.get(5)?;
+                let raw_tx: Option<Vec<u8>> = row.get(6)?;
                 let tx: Option<Transaction> = match raw_tx {
                     Some(raw_tx) => {
                         let tx: Transaction = deserialize(&raw_tx)?;
@@ -494,6 +477,7 @@ impl SqliteDatabase {
                     sent,
                     fee,
                     confirmation_time,
+                    verified,
                 }))
             }
             None => Ok(None),
@@ -640,7 +624,6 @@ impl BatchOperations for SqliteDatabase {
             utxo.outpoint.vout,
             &utxo.outpoint.txid,
             utxo.txout.script_pubkey.as_bytes(),
-            utxo.is_spent,
         )?;
         Ok(())
     }
@@ -715,9 +698,16 @@ impl BatchOperations for SqliteDatabase {
 
     fn del_utxo(&mut self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
         match self.select_utxo_by_outpoint(&outpoint.txid, outpoint.vout)? {
-            Some(local_utxo) => {
+            Some((value, keychain, script_pubkey)) => {
                 self.delete_utxo_by_outpoint(&outpoint.txid, outpoint.vout)?;
-                Ok(Some(local_utxo))
+                Ok(Some(LocalUtxo {
+                    outpoint: *outpoint,
+                    txout: TxOut {
+                        value,
+                        script_pubkey,
+                    },
+                    keychain,
+                }))
             }
             None => Ok(None),
         }
@@ -846,7 +836,17 @@ impl Database for SqliteDatabase {
     }
 
     fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<LocalUtxo>, Error> {
-        self.select_utxo_by_outpoint(&outpoint.txid, outpoint.vout)
+        match self.select_utxo_by_outpoint(&outpoint.txid, outpoint.vout)? {
+            Some((value, keychain, script_pubkey)) => Ok(Some(LocalUtxo {
+                outpoint: *outpoint,
+                txout: TxOut {
+                    value,
+                    script_pubkey,
+                },
+                keychain,
+            })),
+            None => Ok(None),
+        }
     }
 
     fn get_raw_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
@@ -891,6 +891,10 @@ impl Database for SqliteDatabase {
             }
         }
     }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
 }
 
 impl BatchDatabase for SqliteDatabase {
@@ -1026,9 +1030,4 @@ pub mod test {
     fn test_sync_time() {
         crate::database::test::test_sync_time(get_database());
     }
-
-    #[test]
-    fn test_txs() {
-        crate::database::test::test_list_transaction(get_database());
-    }
 }

src/descriptor/derived.rs

@@ -10,41 +10,6 @@
 // licenses.
 
 //! Derived descriptor keys
-//!
-//! The [`DerivedDescriptorKey`] type is a wrapper over the standard [`DescriptorPublicKey`] which
-//! guarantees that all the extended keys have a fixed derivation path, i.e. all the wildcards have
-//! been replaced by actual derivation indexes.
-//!
-//! The [`AsDerived`] trait provides a quick way to derive descriptors to obtain a
-//! `Descriptor<DerivedDescriptorKey>` type. This, in turn, can be used to derive public
-//! keys for arbitrary derivation indexes.
-//!
-//! Combining this with [`Wallet::get_signers`], secret keys can also be derived.
-//!
-//! # Example
-//!
-//! ```
-//! # use std::str::FromStr;
-//! # use bitcoin::secp256k1::Secp256k1;
-//! use bdk::descriptor::{AsDerived, DescriptorPublicKey};
-//! use bdk::miniscript::{ToPublicKey, TranslatePk, MiniscriptKey};
-//!
-//! let secp = Secp256k1::gen_new();
-//!
-//! let key = DescriptorPublicKey::from_str("[aa600a45/84'/0'/0']tpubDCbDXFKoLTQp44wQuC12JgSn5g9CWGjZdpBHeTqyypZ4VvgYjTJmK9CkyR5bFvG9f4PutvwmvpYCLkFx2rpx25hiMs4sUgxJveW8ZzSAVAc/0/*")?;
-//! let (descriptor, _, _) = bdk::descriptor!(wpkh(key))?;
-//!
-//! // derived: wpkh([aa600a45/84'/0'/0']tpubDCbDXFKoLTQp44wQuC12JgSn5g9CWGjZdpBHeTqyypZ4VvgYjTJmK9CkyR5bFvG9f4PutvwmvpYCLkFx2rpx25hiMs4sUgxJveW8ZzSAVAc/0/42)#3ladd0t2
-//! let derived = descriptor.as_derived(42, &secp);
-//! println!("derived: {}", derived);
-//!
-//! // with_pks: wpkh(02373ecb54c5e83bd7e0d40adf78b65efaf12fafb13571f0261fc90364eee22e1e)#p4jjgvll
-//! let with_pks = derived.translate_pk_infallible(|pk| pk.to_public_key(), |pkh| pkh.to_public_key().to_pubkeyhash());
-//! println!("with_pks: {}", with_pks);
-//! # Ok::<(), Box<dyn std::error::Error>>(())
-//! ```
-//!
-//! [`Wallet::get_signers`]: crate::wallet::Wallet::get_signers
 
 use std::cmp::Ordering;
 use std::fmt;
@@ -52,10 +17,13 @@ use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 
 use bitcoin::hashes::hash160;
-use bitcoin::{PublicKey, XOnlyPublicKey};
+use bitcoin::PublicKey;
 
-use miniscript::descriptor::{DescriptorSinglePub, SinglePubKey, Wildcard};
-use miniscript::{Descriptor, DescriptorPublicKey, MiniscriptKey, ToPublicKey, TranslatePk};
+pub use miniscript::{
+    descriptor::KeyMap, descriptor::Wildcard, Descriptor, DescriptorPublicKey, Legacy, Miniscript,
+    ScriptContext, Segwitv0,
+};
+use miniscript::{MiniscriptKey, ToPublicKey, TranslatePk};
 
 use crate::wallet::utils::SecpCtx;
 
@@ -128,44 +96,21 @@ impl<'s> MiniscriptKey for DerivedDescriptorKey<'s> {
     fn is_uncompressed(&self) -> bool {
         self.0.is_uncompressed()
     }
+    fn serialized_len(&self) -> usize {
+        self.0.serialized_len()
+    }
 }
 
 impl<'s> ToPublicKey for DerivedDescriptorKey<'s> {
     fn to_public_key(&self) -> PublicKey {
         match &self.0 {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::XOnly(_),
-                ..
-            }) => panic!("Found x-only public key in non-tr descriptor"),
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::FullKey(ref pk),
-                ..
-            }) => *pk,
-            DescriptorPublicKey::XPub(ref xpub) => PublicKey::new(
+            DescriptorPublicKey::SinglePub(ref spub) => spub.key.to_public_key(),
+            DescriptorPublicKey::XPub(ref xpub) => {
                 xpub.xkey
                     .derive_pub(self.1, &xpub.derivation_path)
                     .expect("Shouldn't fail, only normal derivations")
-                    .public_key,
-            ),
-        }
-    }
-
-    fn to_x_only_pubkey(&self) -> XOnlyPublicKey {
-        match &self.0 {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::XOnly(ref pk),
-                ..
-            }) => *pk,
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::FullKey(ref pk),
-                ..
-            }) => XOnlyPublicKey::from(pk.inner),
-            DescriptorPublicKey::XPub(ref xpub) => XOnlyPublicKey::from(
-                xpub.xkey
-                    .derive_pub(self.1, &xpub.derivation_path)
-                    .expect("Shouldn't fail, only normal derivations")
-                    .public_key,
-            ),
+                    .public_key
+            }
         }
     }
 
@@ -174,19 +119,14 @@ impl<'s> ToPublicKey for DerivedDescriptorKey<'s> {
     }
 }
 
-/// Utilities to derive descriptors
-///
-/// Check out the [module level] documentation for more.
-///
-/// [module level]: crate::descriptor::derived
-pub trait AsDerived {
-    /// Derive a descriptor and transform all of its keys to `DerivedDescriptorKey`
+pub(crate) trait AsDerived {
+    // Derive a descriptor and transform all of its keys to `DerivedDescriptorKey`
     fn as_derived<'s>(&self, index: u32, secp: &'s SecpCtx)
         -> Descriptor<DerivedDescriptorKey<'s>>;
 
-    /// Transform the keys into `DerivedDescriptorKey`.
-    ///
-    /// Panics if the descriptor is not "fixed", i.e. if it's derivable
+    // Transform the keys into `DerivedDescriptorKey`.
+    //
+    // Panics if the descriptor is not "fixed", i.e. if it's derivable
     fn as_derived_fixed<'s>(&self, secp: &'s SecpCtx) -> Descriptor<DerivedDescriptorKey<'s>>;
 }
 

src/descriptor/dsl.rs

@@ -73,48 +73,6 @@ macro_rules! impl_top_level_pk {
     }};
 }
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_top_level_tr {
-    ( $internal_key:expr, $tap_tree:expr ) => {{
-        use $crate::miniscript::descriptor::{
-            Descriptor, DescriptorPublicKey, KeyMap, TapTree, Tr,
-        };
-        use $crate::miniscript::Tap;
-
-        #[allow(unused_imports)]
-        use $crate::keys::{DescriptorKey, IntoDescriptorKey, ValidNetworks};
-
-        let secp = $crate::bitcoin::secp256k1::Secp256k1::new();
-
-        $internal_key
-            .into_descriptor_key()
-            .and_then(|key: DescriptorKey<Tap>| key.extract(&secp))
-            .map_err($crate::descriptor::DescriptorError::Key)
-            .and_then(|(pk, mut key_map, mut valid_networks)| {
-                let tap_tree = $tap_tree.map(
-                    |(tap_tree, tree_keymap, tree_networks): (
-                        TapTree<DescriptorPublicKey>,
-                        KeyMap,
-                        ValidNetworks,
-                    )| {
-                        key_map.extend(tree_keymap.into_iter());
-                        valid_networks =
-                            $crate::keys::merge_networks(&valid_networks, &tree_networks);
-
-                        tap_tree
-                    },
-                );
-
-                Ok((
-                    Descriptor::<DescriptorPublicKey>::Tr(Tr::new(pk, tap_tree)?),
-                    key_map,
-                    valid_networks,
-                ))
-            })
-    }};
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! impl_leaf_opcode {
@@ -270,62 +228,6 @@ macro_rules! impl_sortedmulti {
 
 }
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! parse_tap_tree {
-    ( @merge $tree_a:expr, $tree_b:expr) => {{
-        use std::sync::Arc;
-        use $crate::miniscript::descriptor::TapTree;
-
-        $tree_a
-            .and_then(|tree_a| Ok((tree_a, $tree_b?)))
-            .and_then(|((a_tree, mut a_keymap, a_networks), (b_tree, b_keymap, b_networks))| {
-                a_keymap.extend(b_keymap.into_iter());
-                Ok((TapTree::Tree(Arc::new(a_tree), Arc::new(b_tree)), a_keymap, $crate::keys::merge_networks(&a_networks, &b_networks)))
-            })
-
-    }};
-
-    // Two sub-trees
-    ( { { $( $tree_a:tt )* }, { $( $tree_b:tt )* } } ) => {{
-        let tree_a = $crate::parse_tap_tree!( { $( $tree_a )* } );
-        let tree_b = $crate::parse_tap_tree!( { $( $tree_b )* } );
-
-        $crate::parse_tap_tree!(@merge tree_a, tree_b)
-    }};
-
-    // One leaf and a sub-tree
-    ( { $op_a:ident ( $( $minisc_a:tt )* ), { $( $tree_b:tt )* } } ) => {{
-        let tree_a = $crate::parse_tap_tree!( $op_a ( $( $minisc_a )* ) );
-        let tree_b = $crate::parse_tap_tree!( { $( $tree_b )* } );
-
-        $crate::parse_tap_tree!(@merge tree_a, tree_b)
-    }};
-    ( { { $( $tree_a:tt )* }, $op_b:ident ( $( $minisc_b:tt )* ) } ) => {{
-        let tree_a = $crate::parse_tap_tree!( { $( $tree_a )* } );
-        let tree_b = $crate::parse_tap_tree!( $op_b ( $( $minisc_b )* ) );
-
-        $crate::parse_tap_tree!(@merge tree_a, tree_b)
-    }};
-
-    // Two leaves
-    ( { $op_a:ident ( $( $minisc_a:tt )* ), $op_b:ident ( $( $minisc_b:tt )* ) } ) => {{
-        let tree_a = $crate::parse_tap_tree!( $op_a ( $( $minisc_a )* ) );
-        let tree_b = $crate::parse_tap_tree!( $op_b ( $( $minisc_b )* ) );
-
-        $crate::parse_tap_tree!(@merge tree_a, tree_b)
-    }};
-
-    // Single leaf
-    ( $op:ident ( $( $minisc:tt )* ) ) => {{
-        use std::sync::Arc;
-        use $crate::miniscript::descriptor::TapTree;
-
-        $crate::fragment!( $op ( $( $minisc )* ) )
-            .map(|(a_minisc, a_keymap, a_networks)| (TapTree::Leaf(Arc::new(a_minisc)), a_keymap, a_networks))
-    }};
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! apply_modifier {
@@ -434,7 +336,7 @@ macro_rules! apply_modifier {
 /// syntax is more suitable for a fixed number of items known at compile time, while the other accepts a
 /// [`Vec`] of items, which makes it more suitable for writing dynamic descriptors.
 ///
-/// They both produce the descriptor: `wsh(thresh(2,pk(...),s:pk(...),sndv:older(...)))`
+/// They both produce the descriptor: `wsh(thresh(2,pk(...),s:pk(...),sdv:older(...)))`
 ///
 /// ```
 /// # use std::str::FromStr;
@@ -447,7 +349,7 @@ macro_rules! apply_modifier {
 ///
 /// let (descriptor_a, key_map_a, networks) = bdk::descriptor! {
 ///     wsh (
-///         thresh(2, pk(my_key_1), s:pk(my_key_2), s:n:d:v:older(my_timelock))
+///         thresh(2, pk(my_key_1), s:pk(my_key_2), s:d:v:older(my_timelock))
 ///     )
 /// }?;
 ///
@@ -455,7 +357,7 @@ macro_rules! apply_modifier {
 /// let b_items = vec![
 ///     bdk::fragment!(pk(my_key_1))?,
 ///     bdk::fragment!(s:pk(my_key_2))?,
-///     bdk::fragment!(s:n:d:v:older(my_timelock))?,
+///     bdk::fragment!(s:d:v:older(my_timelock))?,
 /// ];
 /// let (descriptor_b, mut key_map_b, networks) = bdk::descriptor!(wsh(thresh_vec(2, b_items)))?;
 ///
@@ -539,15 +441,6 @@ macro_rules! descriptor {
     ( wsh ( $( $minisc:tt )* ) ) => ({
         $crate::impl_top_level_sh!(Wsh, new, new_sortedmulti, Segwitv0, $( $minisc )*)
     });
-
-    ( tr ( $internal_key:expr ) ) => ({
-        $crate::impl_top_level_tr!($internal_key, None)
-    });
-    ( tr ( $internal_key:expr, $( $taptree:tt )* ) ) => ({
-        let tap_tree = $crate::parse_tap_tree!( $( $taptree )* );
-        tap_tree
-            .and_then(|tap_tree| $crate::impl_top_level_tr!($internal_key, Some(tap_tree)))
-    });
 }
 
 #[doc(hidden)]
@@ -587,23 +480,6 @@ impl<A, B, C> From<(A, (B, (C, ())))> for TupleThree<A, B, C> {
     }
 }
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! group_multi_keys {
-    ( $( $key:expr ),+ ) => {{
-        use $crate::keys::IntoDescriptorKey;
-
-        let keys = vec![
-            $(
-                $key.into_descriptor_key(),
-            )*
-        ];
-
-        keys.into_iter().collect::<Result<Vec<_>, _>>()
-            .map_err($crate::descriptor::DescriptorError::Key)
-    }};
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! fragment_internal {
@@ -764,22 +640,21 @@ macro_rules! fragment {
             .and_then(|items| $crate::fragment!(thresh_vec($thresh, items)))
     });
     ( multi_vec ( $thresh:expr, $keys:expr ) ) => ({
-        let secp = $crate::bitcoin::secp256k1::Secp256k1::new();
-
-        $crate::keys::make_multi($thresh, $crate::miniscript::Terminal::Multi, $keys, &secp)
+        $crate::keys::make_multi($thresh, $keys)
     });
     ( multi ( $thresh:expr $(, $key:expr )+ ) ) => ({
-        $crate::group_multi_keys!( $( $key ),* )
-            .and_then(|keys| $crate::fragment!( multi_vec ( $thresh, keys ) ))
-    });
-    ( multi_a_vec ( $thresh:expr, $keys:expr ) ) => ({
+        use $crate::keys::IntoDescriptorKey;
         let secp = $crate::bitcoin::secp256k1::Secp256k1::new();
 
-        $crate::keys::make_multi($thresh, $crate::miniscript::Terminal::MultiA, $keys, &secp)
-    });
-    ( multi_a ( $thresh:expr $(, $key:expr )+ ) ) => ({
-        $crate::group_multi_keys!( $( $key ),* )
-            .and_then(|keys| $crate::fragment!( multi_a_vec ( $thresh, keys ) ))
+        let keys = vec![
+            $(
+                $key.into_descriptor_key(),
+            )*
+        ];
+
+        keys.into_iter().collect::<Result<Vec<_>, _>>()
+            .map_err($crate::descriptor::DescriptorError::Key)
+            .and_then(|keys| $crate::keys::make_multi($thresh, keys, &secp))
     });
 
     // `sortedmulti()` is handled separately
@@ -1173,15 +1048,13 @@ mod test {
         let private_key =
             PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
         let (descriptor, _, _) =
-            descriptor!(wsh(thresh(2,n:d:v:older(1),s:pk(private_key),s:pk(private_key)))).unwrap();
+            descriptor!(wsh(thresh(2,d:v:older(1),s:pk(private_key),s:pk(private_key)))).unwrap();
 
-        assert_eq!(descriptor.to_string(), "wsh(thresh(2,ndv:older(1),s:pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c),s:pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)))#zzk3ux8g")
+        assert_eq!(descriptor.to_string(), "wsh(thresh(2,dv:older(1),s:pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c),s:pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)))#cfdcqs3s")
     }
 
     #[test]
-    #[should_panic(
-        expected = "Miniscript(ContextError(CompressedOnly(\"04b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a87378ec38ff91d43e8c2092ebda601780485263da089465619e0358a5c1be7ac91f4\")))"
-    )]
+    #[should_panic(expected = "Miniscript(ContextError(CompressedOnly))")]
     fn test_dsl_miniscript_checks() {
         let mut uncompressed_pk =
             PrivateKey::from_wif("L5EZftvrYaSudiozVRzTqLcHLNDoVn7H5HSfM9BAN6tMJX8oTWz6").unwrap();
@@ -1189,35 +1062,4 @@ mod test {
 
         descriptor!(wsh(v: pk(uncompressed_pk))).unwrap();
     }
-
-    #[test]
-    fn test_dsl_tr_only_key() {
-        let private_key =
-            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
-        let (descriptor, _, _) = descriptor!(tr(private_key)).unwrap();
-
-        assert_eq!(
-            descriptor.to_string(),
-            "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)#heq9m95v"
-        )
-    }
-
-    #[test]
-    fn test_dsl_tr_simple_tree() {
-        let private_key =
-            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
-        let (descriptor, _, _) =
-            descriptor!(tr(private_key, { pk(private_key), pk(private_key) })).unwrap();
-
-        assert_eq!(descriptor.to_string(), "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c,{pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c),pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c)})#xy5fjw6d")
-    }
-
-    #[test]
-    fn test_dsl_tr_single_leaf() {
-        let private_key =
-            PrivateKey::from_wif("cSQPHDBwXGjVzWRqAHm6zfvQhaTuj1f2bFH58h55ghbjtFwvmeXR").unwrap();
-        let (descriptor, _, _) = descriptor!(tr(private_key, pk(private_key))).unwrap();
-
-        assert_eq!(descriptor.to_string(), "tr(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c,pk(02e96fe52ef0e22d2f131dd425ce1893073a3c6ad20e8cac36726393dfb4856a4c))#lzl2vmc7")
-    }
 }

src/descriptor/mod.rs

@@ -14,25 +14,23 @@
 //! This module contains generic utilities to work with descriptors, plus some re-exported types
 //! from [`miniscript`].
 
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::ops::Deref;
 
-use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint, KeySource};
-use bitcoin::util::{psbt, taproot};
-use bitcoin::{secp256k1, PublicKey, XOnlyPublicKey};
-use bitcoin::{Network, Script, TxOut};
-
-use miniscript::descriptor::{DescriptorType, InnerXKey, SinglePubKey};
-pub use miniscript::{
-    descriptor::DescriptorXKey, descriptor::KeyMap, descriptor::Wildcard, Descriptor,
-    DescriptorPublicKey, Legacy, Miniscript, ScriptContext, Segwitv0,
+use bitcoin::util::bip32::{
+    ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey, Fingerprint, KeySource,
 };
+use bitcoin::util::psbt;
+use bitcoin::{Network, PublicKey, Script, TxOut};
+
+use miniscript::descriptor::{DescriptorPublicKey, DescriptorType, DescriptorXKey, Wildcard};
+pub use miniscript::{descriptor::KeyMap, Descriptor, Legacy, Miniscript, ScriptContext, Segwitv0};
 use miniscript::{DescriptorTrait, ForEachKey, TranslatePk};
 
 use crate::descriptor::policy::BuildSatisfaction;
 
 pub mod checksum;
-pub mod derived;
+pub(crate) mod derived;
 #[doc(hidden)]
 pub mod dsl;
 pub mod error;
@@ -40,7 +38,8 @@ pub mod policy;
 pub mod template;
 
 pub use self::checksum::get_checksum;
-pub use self::derived::{AsDerived, DerivedDescriptorKey};
+use self::derived::AsDerived;
+pub use self::derived::DerivedDescriptorKey;
 pub use self::error::Error as DescriptorError;
 pub use self::policy::Policy;
 use self::template::DescriptorTemplateOut;
@@ -59,14 +58,7 @@ pub type DerivedDescriptor<'s> = Descriptor<DerivedDescriptorKey<'s>>;
 ///
 /// [`psbt::Input`]: bitcoin::util::psbt::Input
 /// [`psbt::Output`]: bitcoin::util::psbt::Output
-pub type HdKeyPaths = BTreeMap<secp256k1::PublicKey, KeySource>;
-
-/// Alias for the type of maps that represent taproot key origins in a [`psbt::Input`] or
-/// [`psbt::Output`]
-///
-/// [`psbt::Input`]: bitcoin::util::psbt::Input
-/// [`psbt::Output`]: bitcoin::util::psbt::Output
-pub type TapKeyOrigins = BTreeMap<bitcoin::XOnlyPublicKey, (Vec<taproot::TapLeafHash>, KeySource)>;
+pub type HdKeyPaths = BTreeMap<PublicKey, KeySource>;
 
 /// Trait for types which can be converted into an [`ExtendedDescriptor`] and a [`KeyMap`] usable by a wallet in a specific [`Network`]
 pub trait IntoWalletDescriptor {
@@ -134,13 +126,13 @@ impl IntoWalletDescriptor for (ExtendedDescriptor, KeyMap) {
 
         let check_key = |pk: &DescriptorPublicKey| {
             let (pk, _, networks) = if self.0.is_witness() {
-                let descriptor_key: DescriptorKey<miniscript::Segwitv0> =
+                let desciptor_key: DescriptorKey<miniscript::Segwitv0> =
                     pk.clone().into_descriptor_key()?;
-                descriptor_key.extract(secp)?
+                desciptor_key.extract(secp)?
             } else {
-                let descriptor_key: DescriptorKey<miniscript::Legacy> =
+                let desciptor_key: DescriptorKey<miniscript::Legacy> =
                     pk.clone().into_descriptor_key()?;
-                descriptor_key.extract(secp)?
+                desciptor_key.extract(secp)?
             };
 
             if networks.contains(&network) {
@@ -275,10 +267,41 @@ pub(crate) trait XKeyUtils {
     fn root_fingerprint(&self, secp: &SecpCtx) -> Fingerprint;
 }
 
-impl<T> XKeyUtils for DescriptorXKey<T>
-where
-    T: InnerXKey,
-{
+// FIXME: `InnerXKey` was made private in rust-miniscript, so we have to implement this manually on
+// both `ExtendedPubKey` and `ExtendedPrivKey`.
+//
+// Revert back to using the trait once https://github.com/rust-bitcoin/rust-miniscript/pull/230 is
+// released
+impl XKeyUtils for DescriptorXKey<ExtendedPubKey> {
+    fn full_path(&self, append: &[ChildNumber]) -> DerivationPath {
+        let full_path = match self.origin {
+            Some((_, ref path)) => path
+                .into_iter()
+                .chain(self.derivation_path.into_iter())
+                .cloned()
+                .collect(),
+            None => self.derivation_path.clone(),
+        };
+
+        if self.wildcard != Wildcard::None {
+            full_path
+                .into_iter()
+                .chain(append.iter())
+                .cloned()
+                .collect()
+        } else {
+            full_path
+        }
+    }
+
+    fn root_fingerprint(&self, _: &SecpCtx) -> Fingerprint {
+        match self.origin {
+            Some((fingerprint, _)) => fingerprint,
+            None => self.xkey.fingerprint(),
+        }
+    }
+}
+impl XKeyUtils for DescriptorXKey<ExtendedPrivKey> {
     fn full_path(&self, append: &[ChildNumber]) -> DerivationPath {
         let full_path = match self.origin {
             Some((_, ref path)) => path
@@ -303,35 +326,23 @@ where
     fn root_fingerprint(&self, secp: &SecpCtx) -> Fingerprint {
         match self.origin {
             Some((fingerprint, _)) => fingerprint,
-            None => self.xkey.xkey_fingerprint(secp),
+            None => self.xkey.fingerprint(secp),
         }
     }
 }
 
 pub(crate) trait DerivedDescriptorMeta {
-    fn get_hd_keypaths(&self, secp: &SecpCtx) -> HdKeyPaths;
-    fn get_tap_key_origins(&self, secp: &SecpCtx) -> TapKeyOrigins;
+    fn get_hd_keypaths(&self, secp: &SecpCtx) -> Result<HdKeyPaths, DescriptorError>;
 }
 
 pub(crate) trait DescriptorMeta {
     fn is_witness(&self) -> bool;
-    fn is_taproot(&self) -> bool;
     fn get_extended_keys(&self) -> Result<Vec<DescriptorXKey<ExtendedPubKey>>, DescriptorError>;
     fn derive_from_hd_keypaths<'s>(
         &self,
         hd_keypaths: &HdKeyPaths,
         secp: &'s SecpCtx,
     ) -> Option<DerivedDescriptor<'s>>;
-    fn derive_from_tap_key_origins<'s>(
-        &self,
-        tap_key_origins: &TapKeyOrigins,
-        secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
-    fn derive_from_psbt_key_origins<'s>(
-        &self,
-        key_origins: BTreeMap<Fingerprint, (&DerivationPath, SinglePubKey)>,
-        secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
     fn derive_from_psbt_input<'s>(
         &self,
         psbt_input: &psbt::Input,
@@ -348,34 +359,23 @@ pub(crate) trait DescriptorScripts {
 impl<'s> DescriptorScripts for DerivedDescriptor<'s> {
     fn psbt_redeem_script(&self) -> Option<Script> {
         match self.desc_type() {
-            DescriptorType::ShWpkh => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWsh => Some(self.explicit_script().unwrap().to_v0_p2wsh()),
-            DescriptorType::Sh => Some(self.explicit_script().unwrap()),
-            DescriptorType::Bare => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShSortedMulti => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWshSortedMulti => Some(self.explicit_script().unwrap().to_v0_p2wsh()),
-            DescriptorType::Pkh
-            | DescriptorType::Wpkh
-            | DescriptorType::Tr
-            | DescriptorType::Wsh
-            | DescriptorType::WshSortedMulti => None,
+            DescriptorType::ShWpkh => Some(self.explicit_script()),
+            DescriptorType::ShWsh => Some(self.explicit_script().to_v0_p2wsh()),
+            DescriptorType::Sh => Some(self.explicit_script()),
+            DescriptorType::Bare => Some(self.explicit_script()),
+            DescriptorType::ShSortedMulti => Some(self.explicit_script()),
+            _ => None,
         }
     }
 
     fn psbt_witness_script(&self) -> Option<Script> {
         match self.desc_type() {
-            DescriptorType::Wsh => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWsh => Some(self.explicit_script().unwrap()),
+            DescriptorType::Wsh => Some(self.explicit_script()),
+            DescriptorType::ShWsh => Some(self.explicit_script()),
             DescriptorType::WshSortedMulti | DescriptorType::ShWshSortedMulti => {
-                Some(self.explicit_script().unwrap())
+                Some(self.explicit_script())
             }
-            DescriptorType::Bare
-            | DescriptorType::Sh
-            | DescriptorType::Pkh
-            | DescriptorType::Wpkh
-            | DescriptorType::ShSortedMulti
-            | DescriptorType::Tr
-            | DescriptorType::ShWpkh => None,
+            _ => None,
         }
     }
 }
@@ -393,10 +393,6 @@ impl DescriptorMeta for ExtendedDescriptor {
         )
     }
 
-    fn is_taproot(&self) -> bool {
-        self.desc_type() == DescriptorType::Tr
-    }
-
     fn get_extended_keys(&self) -> Result<Vec<DescriptorXKey<ExtendedPubKey>>, DescriptorError> {
         let mut answer = Vec::new();
 
@@ -411,122 +407,59 @@ impl DescriptorMeta for ExtendedDescriptor {
         Ok(answer)
     }
 
-    fn derive_from_psbt_key_origins<'s>(
-        &self,
-        key_origins: BTreeMap<Fingerprint, (&DerivationPath, SinglePubKey)>,
-        secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
-        // Ensure that deriving `xpub` with `path` yields `expected`
-        let verify_key = |xpub: &DescriptorXKey<ExtendedPubKey>,
-                          path: &DerivationPath,
-                          expected: &SinglePubKey| {
-            let derived = xpub
-                .xkey
-                .derive_pub(secp, path)
-                .expect("The path should never contain hardened derivation steps")
-                .public_key;
-
-            match expected {
-                SinglePubKey::FullKey(pk) if &PublicKey::new(derived) == pk => true,
-                SinglePubKey::XOnly(pk) if &XOnlyPublicKey::from(derived) == pk => true,
-                _ => false,
-            }
-        };
-
-        let mut path_found = None;
-
-        // using `for_any_key` should make this stop as soon as we return `true`
-        self.for_any_key(|key| {
-            if let DescriptorPublicKey::XPub(xpub) = key.as_key().deref() {
-                // Check if the key matches one entry in our `key_origins`. If it does, `matches()` will
-                // return the "prefix" that matched, so we remove that prefix from the full path
-                // found in `key_origins` and save it in `derive_path`. We expect this to be a derivation
-                // path of length 1 if the key is `wildcard` and an empty path otherwise.
-                let root_fingerprint = xpub.root_fingerprint(secp);
-                let derive_path = key_origins
-                    .get_key_value(&root_fingerprint)
-                    .and_then(|(fingerprint, (path, expected))| {
-                        xpub.matches(&(*fingerprint, (*path).clone()), secp)
-                            .zip(Some((path, expected)))
-                    })
-                    .and_then(|(prefix, (full_path, expected))| {
-                        let derive_path = full_path
-                            .into_iter()
-                            .skip(prefix.into_iter().count())
-                            .cloned()
-                            .collect::<DerivationPath>();
-
-                        // `derive_path` only contains the replacement index for the wildcard, if present, or
-                        // an empty path for fixed descriptors. To verify the key we also need the normal steps
-                        // that come before the wildcard, so we take them directly from `xpub` and then append
-                        // the final index
-                        if verify_key(
-                            xpub,
-                            &xpub.derivation_path.extend(derive_path.clone()),
-                            expected,
-                        ) {
-                            Some(derive_path)
-                        } else {
-                            log::debug!(
-                                "Key `{}` derived with {} yields an unexpected key",
-                                root_fingerprint,
-                                derive_path
-                            );
-                            None
-                        }
-                    });
-
-                match derive_path {
-                    Some(path) if xpub.wildcard != Wildcard::None && path.len() == 1 => {
-                        // Ignore hardened wildcards
-                        if let ChildNumber::Normal { index } = path[0] {
-                            path_found = Some(index);
-                            return true;
-                        }
-                    }
-                    Some(path) if xpub.wildcard == Wildcard::None && path.is_empty() => {
-                        path_found = Some(0);
-                        return true;
-                    }
-                    _ => {}
-                }
-            }
-
-            false
-        });
-
-        path_found.map(|path| self.as_derived(path, secp))
-    }
-
     fn derive_from_hd_keypaths<'s>(
         &self,
         hd_keypaths: &HdKeyPaths,
         secp: &'s SecpCtx,
     ) -> Option<DerivedDescriptor<'s>> {
-        // "Convert" an hd_keypaths map to the format required by `derive_from_psbt_key_origins`
-        let key_origins = hd_keypaths
-            .iter()
-            .map(|(pk, (fingerprint, path))| {
-                (
-                    *fingerprint,
-                    (path, SinglePubKey::FullKey(PublicKey::new(*pk))),
-                )
-            })
-            .collect();
-        self.derive_from_psbt_key_origins(key_origins, secp)
-    }
+        let index: HashMap<_, _> = hd_keypaths.values().map(|(a, b)| (a, b)).collect();
 
-    fn derive_from_tap_key_origins<'s>(
-        &self,
-        tap_key_origins: &TapKeyOrigins,
-        secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
-        // "Convert" a tap_key_origins map to the format required by `derive_from_psbt_key_origins`
-        let key_origins = tap_key_origins
-            .iter()
-            .map(|(pk, (_, (fingerprint, path)))| (*fingerprint, (path, SinglePubKey::XOnly(*pk))))
-            .collect();
-        self.derive_from_psbt_key_origins(key_origins, secp)
+        let mut path_found = None;
+        self.for_each_key(|key| {
+            if path_found.is_some() {
+                // already found a matching path, we are done
+                return true;
+            }
+
+            if let DescriptorPublicKey::XPub(xpub) = key.as_key().deref() {
+                // Check if the key matches one entry in our `index`. If it does, `matches()` will
+                // return the "prefix" that matched, so we remove that prefix from the full path
+                // found in `index` and save it in `derive_path`. We expect this to be a derivation
+                // path of length 1 if the key is `wildcard` and an empty path otherwise.
+                let root_fingerprint = xpub.root_fingerprint(secp);
+                let derivation_path: Option<Vec<ChildNumber>> = index
+                    .get_key_value(&root_fingerprint)
+                    .and_then(|(fingerprint, path)| {
+                        xpub.matches(&(**fingerprint, (*path).clone()), secp)
+                    })
+                    .map(|prefix| {
+                        index
+                            .get(&xpub.root_fingerprint(secp))
+                            .unwrap()
+                            .into_iter()
+                            .skip(prefix.into_iter().count())
+                            .cloned()
+                            .collect()
+                    });
+
+                match derivation_path {
+                    Some(path) if xpub.wildcard != Wildcard::None && path.len() == 1 => {
+                        // Ignore hardened wildcards
+                        if let ChildNumber::Normal { index } = path[0] {
+                            path_found = Some(index)
+                        }
+                    }
+                    Some(path) if xpub.wildcard == Wildcard::None && path.is_empty() => {
+                        path_found = Some(0)
+                    }
+                    _ => {}
+                }
+            }
+
+            true
+        });
+
+        path_found.map(|path| self.as_derived(path, secp))
     }
 
     fn derive_from_psbt_input<'s>(
@@ -538,9 +471,6 @@ impl DescriptorMeta for ExtendedDescriptor {
         if let Some(derived) = self.derive_from_hd_keypaths(&psbt_input.bip32_derivation, secp) {
             return Some(derived);
         }
-        if let Some(derived) = self.derive_from_tap_key_origins(&psbt_input.tap_key_origins, secp) {
-            return Some(derived);
-        }
         if self.is_deriveable() {
             // We can't try to bruteforce the derivation index, exit here
             return None;
@@ -549,10 +479,7 @@ impl DescriptorMeta for ExtendedDescriptor {
         let descriptor = self.as_derived_fixed(secp);
         match descriptor.desc_type() {
             // TODO: add pk() here
-            DescriptorType::Pkh
-            | DescriptorType::Wpkh
-            | DescriptorType::ShWpkh
-            | DescriptorType::Tr
+            DescriptorType::Pkh | DescriptorType::Wpkh | DescriptorType::ShWpkh
                 if utxo.is_some()
                     && descriptor.script_pubkey() == utxo.as_ref().unwrap().script_pubkey =>
             {
@@ -560,7 +487,7 @@ impl DescriptorMeta for ExtendedDescriptor {
             }
             DescriptorType::Bare | DescriptorType::Sh | DescriptorType::ShSortedMulti
                 if psbt_input.redeem_script.is_some()
-                    && &descriptor.explicit_script().unwrap()
+                    && &descriptor.explicit_script()
                         == psbt_input.redeem_script.as_ref().unwrap() =>
             {
                 Some(descriptor)
@@ -570,7 +497,7 @@ impl DescriptorMeta for ExtendedDescriptor {
             | DescriptorType::ShWshSortedMulti
             | DescriptorType::WshSortedMulti
                 if psbt_input.witness_script.is_some()
-                    && &descriptor.explicit_script().unwrap()
+                    && &descriptor.explicit_script()
                         == psbt_input.witness_script.as_ref().unwrap() =>
             {
                 Some(descriptor)
@@ -581,7 +508,7 @@ impl DescriptorMeta for ExtendedDescriptor {
 }
 
 impl<'s> DerivedDescriptorMeta for DerivedDescriptor<'s> {
-    fn get_hd_keypaths(&self, secp: &SecpCtx) -> HdKeyPaths {
+    fn get_hd_keypaths(&self, secp: &SecpCtx) -> Result<HdKeyPaths, DescriptorError> {
         let mut answer = BTreeMap::new();
         self.for_each_key(|key| {
             if let DescriptorPublicKey::XPub(xpub) = key.as_key().deref() {
@@ -599,64 +526,7 @@ impl<'s> DerivedDescriptorMeta for DerivedDescriptor<'s> {
             true
         });
 
-        answer
-    }
-
-    fn get_tap_key_origins(&self, secp: &SecpCtx) -> TapKeyOrigins {
-        use miniscript::ToPublicKey;
-
-        let mut answer = BTreeMap::new();
-        let mut insert_path = |pk: &DerivedDescriptorKey<'_>, lh| {
-            let key_origin = match pk.deref() {
-                DescriptorPublicKey::XPub(xpub) => {
-                    Some((xpub.root_fingerprint(secp), xpub.full_path(&[])))
-                }
-                DescriptorPublicKey::SinglePub(_) => None,
-            };
-
-            // If this is the internal key, we only insert the key origin if it's not None.
-            // For keys found in the tap tree we always insert a key origin (because the signer
-            // looks for it to know which leaves to sign for), even though it may be None
-            match (lh, key_origin) {
-                (None, Some(ko)) => {
-                    answer
-                        .entry(pk.to_x_only_pubkey())
-                        .or_insert_with(|| (vec![], ko));
-                }
-                (Some(lh), origin) => {
-                    answer
-                        .entry(pk.to_x_only_pubkey())
-                        .or_insert_with(|| (vec![], origin.unwrap_or_default()))
-                        .0
-                        .push(lh);
-                }
-                _ => {}
-            }
-        };
-
-        if let Descriptor::Tr(tr) = &self {
-            // Internal key first, then iterate the scripts
-            insert_path(tr.internal_key(), None);
-
-            for (_, ms) in tr.iter_scripts() {
-                // Assume always the same leaf version
-                let leaf_hash = taproot::TapLeafHash::from_script(
-                    &ms.encode(),
-                    taproot::LeafVersion::TapScript,
-                );
-
-                for key in ms.iter_pk_pkh() {
-                    let key = match key {
-                        miniscript::miniscript::iter::PkPkh::PlainPubkey(pk) => pk,
-                        miniscript::miniscript::iter::PkPkh::HashedPubkey(pk) => pk,
-                    };
-
-                    insert_path(&key, Some(leaf_hash));
-                }
-            }
-        }
-
-        answer
+        Ok(answer)
     }
 }
 
@@ -668,7 +538,6 @@ mod test {
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::secp256k1::Secp256k1;
     use bitcoin::util::{bip32, psbt};
-    use bitcoin::Script;
 
     use super::*;
     use crate::psbt::PsbtUtils;
@@ -932,22 +801,4 @@ mod test {
             DescriptorError::DuplicatedKeys
         ));
     }
-
-    #[test]
-    fn test_sh_wsh_sortedmulti_redeemscript() {
-        use super::{AsDerived, DescriptorScripts};
-
-        let secp = Secp256k1::new();
-
-        let descriptor = "sh(wsh(sortedmulti(3,tpubDEsqS36T4DVsKJd9UH8pAKzrkGBYPLEt9jZMwpKtzh1G6mgYehfHt9WCgk7MJG5QGSFWf176KaBNoXbcuFcuadAFKxDpUdMDKGBha7bY3QM/0/*,tpubDF3cpwfs7fMvXXuoQbohXtLjNM6ehwYT287LWtmLsd4r77YLg6MZg4vTETx5MSJ2zkfigbYWu31VA2Z2Vc1cZugCYXgS7FQu6pE8V6TriEH/0/*,tpubDE1SKfcW76Tb2AASv5bQWMuScYNAdoqLHoexw13sNDXwmUhQDBbCD3QAedKGLhxMrWQdMDKENzYtnXPDRvexQPNuDrLj52wAjHhNEm8sJ4p/0/*,tpubDFLc6oXwJmhm3FGGzXkfJNTh2KitoY3WhmmQvuAjMhD8YbyWn5mAqckbxXfm2etM3p5J6JoTpSrMqRSTfMLtNW46poDaEZJ1kjd3csRSjwH/0/*,tpubDEWD9NBeWP59xXmdqSNt4VYdtTGwbpyP8WS962BuqpQeMZmX9Pur14dhXdZT5a7wR1pK6dPtZ9fP5WR493hPzemnBvkfLLYxnUjAKj1JCQV/0/*,tpubDEHyZkkwd7gZWCTgQuYQ9C4myF2hMEmyHsBCCmLssGqoqUxeT3gzohF5uEVURkf9TtmeepJgkSUmteac38FwZqirjApzNX59XSHLcwaTZCH/0/*,tpubDEqLouCekwnMUWN486kxGzD44qVgeyuqHyxUypNEiQt5RnUZNJe386TKPK99fqRV1vRkZjYAjtXGTECz98MCsdLcnkM67U6KdYRzVubeCgZ/0/*)))";
-        let (descriptor, _) =
-            into_wallet_descriptor_checked(descriptor, &secp, Network::Testnet).unwrap();
-
-        let descriptor = descriptor.as_derived(0, &secp);
-
-        let script = Script::from_str("5321022f533b667e2ea3b36e21961c9fe9dca340fbe0af5210173a83ae0337ab20a57621026bb53a98e810bd0ee61a0ed1164ba6c024786d76554e793e202dc6ce9c78c4ea2102d5b8a7d66a41ffdb6f4c53d61994022e886b4f45001fb158b95c9164d45f8ca3210324b75eead2c1f9c60e8adeb5e7009fec7a29afcdb30d829d82d09562fe8bae8521032d34f8932200833487bd294aa219dcbe000b9f9b3d824799541430009f0fa55121037468f8ea99b6c64788398b5ad25480cad08f4b0d65be54ce3a55fd206b5ae4722103f72d3d96663b0ea99b0aeb0d7f273cab11a8de37885f1dddc8d9112adb87169357ae").unwrap();
-
-        assert_eq!(descriptor.psbt_redeem_script(), Some(script.to_v0_p2wsh()));
-        assert_eq!(descriptor.psbt_witness_script(), Some(script));
-    }
 }

src/descriptor/policy.rs

@@ -21,7 +21,6 @@
 //! ```
 //! # use std::sync::Arc;
 //! # use bdk::descriptor::*;
-//! # use bdk::wallet::signer::*;
 //! # use bdk::bitcoin::secp256k1::Secp256k1;
 //! use bdk::descriptor::policy::BuildSatisfaction;
 //! let secp = Secp256k1::new();
@@ -30,7 +29,7 @@
 //! let (extended_desc, key_map) = ExtendedDescriptor::parse_descriptor(&secp, desc)?;
 //! println!("{:?}", extended_desc);
 //!
-//! let signers = Arc::new(SignersContainer::build(key_map, &extended_desc, &secp));
+//! let signers = Arc::new(key_map.into());
 //! let policy = extended_desc.extract_policy(&signers, BuildSatisfaction::None, &secp)?;
 //! println!("policy: {}", serde_json::to_string(&policy)?);
 //! # Ok::<(), bdk::Error>(())
@@ -45,64 +44,59 @@ use serde::{Serialize, Serializer};
 
 use bitcoin::hashes::*;
 use bitcoin::util::bip32::Fingerprint;
-use bitcoin::{PublicKey, XOnlyPublicKey};
+use bitcoin::PublicKey;
 
-use miniscript::descriptor::{
-    DescriptorPublicKey, DescriptorSinglePub, ShInner, SinglePubKey, SortedMultiVec, WshInner,
-};
+use miniscript::descriptor::{DescriptorPublicKey, ShInner, SortedMultiVec, WshInner};
 use miniscript::{Descriptor, Miniscript, MiniscriptKey, Satisfier, ScriptContext, Terminal};
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
 use crate::descriptor::ExtractPolicy;
-use crate::keys::ExtScriptContext;
 use crate::wallet::signer::{SignerId, SignersContainer};
 use crate::wallet::utils::{self, After, Older, SecpCtx};
 
 use super::checksum::get_checksum;
 use super::error::Error;
 use super::XKeyUtils;
-use bitcoin::util::psbt::{Input as PsbtInput, PartiallySignedTransaction as Psbt};
+use bitcoin::util::psbt::PartiallySignedTransaction as Psbt;
 use miniscript::psbt::PsbtInputSatisfier;
 
-/// A unique identifier for a key
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum PkOrF {
-    /// A legacy public key
-    Pubkey(PublicKey),
-    /// A x-only public key
-    XOnlyPubkey(XOnlyPublicKey),
-    /// An extended key fingerprint
-    Fingerprint(Fingerprint),
+/// Raw public key or extended key fingerprint
+#[derive(Debug, Clone, Default, Serialize)]
+pub struct PkOrF {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pubkey: Option<PublicKey>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pubkey_hash: Option<hash160::Hash>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fingerprint: Option<Fingerprint>,
 }
 
 impl PkOrF {
     fn from_key(k: &DescriptorPublicKey, secp: &SecpCtx) -> Self {
         match k {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::FullKey(pk),
-                ..
-            }) => PkOrF::Pubkey(*pk),
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::XOnly(pk),
-                ..
-            }) => PkOrF::XOnlyPubkey(*pk),
-            DescriptorPublicKey::XPub(xpub) => PkOrF::Fingerprint(xpub.root_fingerprint(secp)),
+            DescriptorPublicKey::SinglePub(pubkey) => PkOrF {
+                pubkey: Some(pubkey.key),
+                ..Default::default()
+            },
+            DescriptorPublicKey::XPub(xpub) => PkOrF {
+                fingerprint: Some(xpub.root_fingerprint(secp)),
+                ..Default::default()
+            },
         }
     }
 }
 
 /// An item that needs to be satisfied
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type", rename_all = "UPPERCASE")]
 pub enum SatisfiableItem {
     // Leaves
-    /// ECDSA Signature for a raw public key
-    EcdsaSignature(PkOrF),
-    /// Schnorr Signature for a raw public key
-    SchnorrSignature(PkOrF),
+    /// Signature for a raw public key
+    Signature(PkOrF),
+    /// Signature for an extended key fingerprint
+    SignatureKey(PkOrF),
     /// SHA256 preimage hash
     Sha256Preimage {
         /// The digest value
@@ -249,7 +243,7 @@ where
 }
 
 /// Represent if and how much a policy item is satisfied by the wallet's descriptor
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type", rename_all = "UPPERCASE")]
 pub enum Satisfaction {
     /// Only a partial satisfaction of some kind of threshold policy
@@ -363,8 +357,7 @@ impl Satisfaction {
                     // we map each of the combinations of elements into a tuple of ([chosen items], [conditions]). unfortunately, those items have potentially more than one
                     // condition (think about ORs), so we also use `mix` to expand those, i.e. [[0], [1, 2]] becomes [[0, 1], [0, 2]]. This is necessary to make sure that we
                     // consider every possible options and check whether or not they are compatible.
-                    // since this step can turn one item of the iterator into multiple ones, we use `flat_map()` to expand them out
-                    .flat_map(|i_vec| {
+                    .map(|i_vec| {
                         mix(i_vec
                             .iter()
                             .map(|i| {
@@ -378,6 +371,9 @@ impl Satisfaction {
                         .map(|x| (i_vec.clone(), x))
                         .collect::<Vec<(Vec<usize>, Vec<Condition>)>>()
                     })
+                    // .inspect(|x: &Vec<(Vec<usize>, Vec<Condition>)>| println!("fetch {:?}", x))
+                    // since the previous step can turn one item of the iterator into multiple ones, we call flatten to expand them out
+                    .flatten()
                     // .inspect(|x| println!("flat {:?}", x))
                     // try to fold all the conditions for this specific combination of indexes/options. if they are not compatible, try_fold will be Err
                     .map(|(key, val)| {
@@ -423,7 +419,7 @@ impl From<bool> for Satisfaction {
 }
 
 /// Descriptor spending policy
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Policy {
     /// Identifier for this policy node
     pub id: String,
@@ -571,7 +567,7 @@ impl Policy {
         Ok(Some(policy))
     }
 
-    fn make_multisig<Ctx: ScriptContext + 'static>(
+    fn make_multisig(
         keys: &[DescriptorPublicKey],
         signers: &SignersContainer,
         build_sat: BuildSatisfaction,
@@ -605,7 +601,7 @@ impl Policy {
             }
 
             if let Some(psbt) = build_sat.psbt() {
-                if Ctx::find_signature(psbt, key, secp) {
+                if signature_in_psbt(psbt, key, secp) {
                     satisfaction.add(
                         &Satisfaction::Complete {
                             condition: Default::default(),
@@ -721,27 +717,18 @@ impl From<SatisfiableItem> for Policy {
 
 fn signer_id(key: &DescriptorPublicKey, secp: &SecpCtx) -> SignerId {
     match key {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-            key: SinglePubKey::FullKey(pk),
-            ..
-        }) => pk.to_pubkeyhash().into(),
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-            key: SinglePubKey::XOnly(pk),
-            ..
-        }) => pk.to_pubkeyhash().into(),
+        DescriptorPublicKey::SinglePub(pubkey) => pubkey.key.to_pubkeyhash().into(),
         DescriptorPublicKey::XPub(xpub) => xpub.root_fingerprint(secp).into(),
     }
 }
 
-fn make_generic_signature<M: Fn() -> SatisfiableItem, F: Fn(&Psbt) -> bool>(
+fn signature(
     key: &DescriptorPublicKey,
     signers: &SignersContainer,
     build_sat: BuildSatisfaction,
     secp: &SecpCtx,
-    make_policy: M,
-    find_sig: F,
 ) -> Policy {
-    let mut policy: Policy = make_policy().into();
+    let mut policy: Policy = SatisfiableItem::Signature(PkOrF::from_key(key, secp)).into();
 
     policy.contribution = if signers.find(signer_id(key, secp)).is_some() {
         Satisfaction::Complete {
@@ -752,7 +739,7 @@ fn make_generic_signature<M: Fn() -> SatisfiableItem, F: Fn(&Psbt) -> bool>(
     };
 
     if let Some(psbt) = build_sat.psbt() {
-        policy.satisfaction = if find_sig(psbt) {
+        policy.satisfaction = if signature_in_psbt(psbt, key, secp) {
             Satisfaction::Complete {
                 condition: Default::default(),
             }
@@ -764,119 +751,26 @@ fn make_generic_signature<M: Fn() -> SatisfiableItem, F: Fn(&Psbt) -> bool>(
     policy
 }
 
-fn generic_sig_in_psbt<
-    // C is for "check", it's a closure we use to *check* if a psbt input contains the signature
-    // for a specific key
-    C: Fn(&PsbtInput, &SinglePubKey) -> bool,
-    // E is for "extract", it extracts a key from the bip32 derivations found in the psbt input
-    E: Fn(&PsbtInput, Fingerprint) -> Option<SinglePubKey>,
->(
-    psbt: &Psbt,
-    key: &DescriptorPublicKey,
-    secp: &SecpCtx,
-    check: C,
-    extract: E,
-) -> bool {
+fn signature_in_psbt(psbt: &Psbt, key: &DescriptorPublicKey, secp: &SecpCtx) -> bool {
     //TODO check signature validity
     psbt.inputs.iter().all(|input| match key {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub { key, .. }) => check(input, key),
+        DescriptorPublicKey::SinglePub(key) => input.partial_sigs.contains_key(&key.key),
         DescriptorPublicKey::XPub(xpub) => {
+            let pubkey = input
+                .bip32_derivation
+                .iter()
+                .find(|(_, (f, _))| *f == xpub.root_fingerprint(secp))
+                .map(|(p, _)| p);
             //TODO check actual derivation matches
-            match extract(input, xpub.root_fingerprint(secp)) {
-                Some(pubkey) => check(input, &pubkey),
+            match pubkey {
+                Some(pubkey) => input.partial_sigs.contains_key(pubkey),
                 None => false,
             }
         }
     })
 }
 
-trait SigExt: ScriptContext {
-    fn make_signature(
-        key: &DescriptorPublicKey,
-        signers: &SignersContainer,
-        build_sat: BuildSatisfaction,
-        secp: &SecpCtx,
-    ) -> Policy;
-
-    fn find_signature(psbt: &Psbt, key: &DescriptorPublicKey, secp: &SecpCtx) -> bool;
-}
-
-impl<T: ScriptContext + 'static> SigExt for T {
-    fn make_signature(
-        key: &DescriptorPublicKey,
-        signers: &SignersContainer,
-        build_sat: BuildSatisfaction,
-        secp: &SecpCtx,
-    ) -> Policy {
-        if T::as_enum().is_taproot() {
-            make_generic_signature(
-                key,
-                signers,
-                build_sat,
-                secp,
-                || SatisfiableItem::SchnorrSignature(PkOrF::from_key(key, secp)),
-                |psbt| Self::find_signature(psbt, key, secp),
-            )
-        } else {
-            make_generic_signature(
-                key,
-                signers,
-                build_sat,
-                secp,
-                || SatisfiableItem::EcdsaSignature(PkOrF::from_key(key, secp)),
-                |psbt| Self::find_signature(psbt, key, secp),
-            )
-        }
-    }
-
-    fn find_signature(psbt: &Psbt, key: &DescriptorPublicKey, secp: &SecpCtx) -> bool {
-        if T::as_enum().is_taproot() {
-            generic_sig_in_psbt(
-                psbt,
-                key,
-                secp,
-                |input, pk| {
-                    let pk = match pk {
-                        SinglePubKey::XOnly(pk) => pk,
-                        _ => return false,
-                    };
-
-                    if input.tap_internal_key == Some(*pk) && input.tap_key_sig.is_some() {
-                        true
-                    } else {
-                        input.tap_script_sigs.keys().any(|(sk, _)| sk == pk)
-                    }
-                },
-                |input, fing| {
-                    input
-                        .tap_key_origins
-                        .iter()
-                        .find(|(_, (_, (f, _)))| f == &fing)
-                        .map(|(pk, _)| SinglePubKey::XOnly(*pk))
-                },
-            )
-        } else {
-            generic_sig_in_psbt(
-                psbt,
-                key,
-                secp,
-                |input, pk| match pk {
-                    SinglePubKey::FullKey(pk) => input.partial_sigs.contains_key(pk),
-                    _ => false,
-                },
-                |input, fing| {
-                    input
-                        .bip32_derivation
-                        .iter()
-                        .find(|(_, (f, _))| f == &fing)
-                        .map(|(pk, _)| SinglePubKey::FullKey(PublicKey::new(*pk)))
-                },
-            )
-        }
-    }
-}
-
-impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublicKey, Ctx> {
+impl<Ctx: ScriptContext> ExtractPolicy for Miniscript<DescriptorPublicKey, Ctx> {
     fn extract_policy(
         &self,
         signers: &SignersContainer,
@@ -886,10 +780,8 @@ impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublic
         Ok(match &self.node {
             // Leaves
             Terminal::True | Terminal::False => None,
-            Terminal::PkK(pubkey) => Some(Ctx::make_signature(pubkey, signers, build_sat, secp)),
-            Terminal::PkH(pubkey_hash) => {
-                Some(Ctx::make_signature(pubkey_hash, signers, build_sat, secp))
-            }
+            Terminal::PkK(pubkey) => Some(signature(pubkey, signers, build_sat, secp)),
+            Terminal::PkH(pubkey_hash) => Some(signature(pubkey_hash, signers, build_sat, secp)),
             Terminal::After(value) => {
                 let mut policy: Policy = SatisfiableItem::AbsoluteTimelock { value: *value }.into();
                 policy.contribution = Satisfaction::Complete {
@@ -950,8 +842,8 @@ impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublic
             Terminal::Hash160(hash) => {
                 Some(SatisfiableItem::Hash160Preimage { hash: *hash }.into())
             }
-            Terminal::Multi(k, pks) | Terminal::MultiA(k, pks) => {
-                Policy::make_multisig::<Ctx>(pks, signers, build_sat, *k, false, secp)?
+            Terminal::Multi(k, pks) => {
+                Policy::make_multisig(pks, signers, build_sat, *k, false, secp)?
             }
             // Identities
             Terminal::Alt(inner)
@@ -1042,13 +934,13 @@ impl ExtractPolicy for Descriptor<DescriptorPublicKey> {
         build_sat: BuildSatisfaction,
         secp: &SecpCtx,
     ) -> Result<Option<Policy>, Error> {
-        fn make_sortedmulti<Ctx: ScriptContext + 'static>(
+        fn make_sortedmulti<Ctx: ScriptContext>(
             keys: &SortedMultiVec<DescriptorPublicKey, Ctx>,
             signers: &SignersContainer,
             build_sat: BuildSatisfaction,
             secp: &SecpCtx,
         ) -> Result<Option<Policy>, Error> {
-            Ok(Policy::make_multisig::<Ctx>(
+            Ok(Policy::make_multisig(
                 keys.pks.as_ref(),
                 signers,
                 build_sat,
@@ -1059,25 +951,10 @@ impl ExtractPolicy for Descriptor<DescriptorPublicKey> {
         }
 
         match self {
-            Descriptor::Pkh(pk) => Ok(Some(miniscript::Legacy::make_signature(
-                pk.as_inner(),
-                signers,
-                build_sat,
-                secp,
-            ))),
-            Descriptor::Wpkh(pk) => Ok(Some(miniscript::Segwitv0::make_signature(
-                pk.as_inner(),
-                signers,
-                build_sat,
-                secp,
-            ))),
+            Descriptor::Pkh(pk) => Ok(Some(signature(pk.as_inner(), signers, build_sat, secp))),
+            Descriptor::Wpkh(pk) => Ok(Some(signature(pk.as_inner(), signers, build_sat, secp))),
             Descriptor::Sh(sh) => match sh.as_inner() {
-                ShInner::Wpkh(pk) => Ok(Some(miniscript::Segwitv0::make_signature(
-                    pk.as_inner(),
-                    signers,
-                    build_sat,
-                    secp,
-                ))),
+                ShInner::Wpkh(pk) => Ok(Some(signature(pk.as_inner(), signers, build_sat, secp))),
                 ShInner::Ms(ms) => Ok(ms.extract_policy(signers, build_sat, secp)?),
                 ShInner::SortedMulti(ref keys) => make_sortedmulti(keys, signers, build_sat, secp),
                 ShInner::Wsh(wsh) => match wsh.as_inner() {
@@ -1092,28 +969,6 @@ impl ExtractPolicy for Descriptor<DescriptorPublicKey> {
                 WshInner::SortedMulti(ref keys) => make_sortedmulti(keys, signers, build_sat, secp),
             },
             Descriptor::Bare(ms) => Ok(ms.as_inner().extract_policy(signers, build_sat, secp)?),
-            Descriptor::Tr(tr) => {
-                // If there's no tap tree, treat this as a single sig, otherwise build a `Thresh`
-                // node with threshold = 1 and the key spend signature plus all the tree leaves
-                let key_spend_sig =
-                    miniscript::Tap::make_signature(tr.internal_key(), signers, build_sat, secp);
-
-                if tr.taptree().is_none() {
-                    Ok(Some(key_spend_sig))
-                } else {
-                    let mut items = vec![key_spend_sig];
-                    items.append(
-                        &mut tr
-                            .iter_scripts()
-                            .filter_map(|(_, ms)| {
-                                ms.extract_policy(signers, build_sat, secp).transpose()
-                            })
-                            .collect::<Result<Vec<_>, _>>()?,
-                    );
-
-                    Ok(Policy::make_thresh(items, 1)?)
-                }
-            }
         }
     }
 }
@@ -1125,7 +980,7 @@ mod test {
 
     use super::*;
     use crate::descriptor::derived::AsDerived;
-    use crate::descriptor::policy::SatisfiableItem::{EcdsaSignature, Multisig, Thresh};
+    use crate::descriptor::policy::SatisfiableItem::{Multisig, Signature, Thresh};
     use crate::keys::{DescriptorKey, IntoDescriptorKey};
     use crate::wallet::signer::SignersContainer;
     use bitcoin::secp256k1::Secp256k1;
@@ -1147,7 +1002,7 @@ mod test {
     ) -> (DescriptorKey<Ctx>, DescriptorKey<Ctx>, Fingerprint) {
         let path = bip32::DerivationPath::from_str(path).unwrap();
         let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
-        let tpub = bip32::ExtendedPubKey::from_priv(secp, &tprv);
+        let tpub = bip32::ExtendedPubKey::from_private(secp, &tprv);
         let fingerprint = tprv.fingerprint(secp);
         let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
         let pubkey = (tpub, path).into_descriptor_key().unwrap();
@@ -1166,26 +1021,30 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
+        assert!(
+            matches!(&policy.item, Signature(pk_or_f) if pk_or_f.fingerprint.unwrap() == fingerprint)
+        );
         assert!(matches!(&policy.contribution, Satisfaction::None));
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
+        assert!(
+            matches!(&policy.item, Signature(pk_or_f) if pk_or_f.fingerprint.unwrap() == fingerprint)
+        );
         assert!(
             matches!(&policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
         );
@@ -1201,7 +1060,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1209,8 +1068,8 @@ mod test {
 
         assert!(
             matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
-            && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[0].fingerprint.unwrap() == fingerprint0
+            && keys[1].fingerprint.unwrap() == fingerprint1)
         );
         // TODO should this be "Satisfaction::None" since we have no prv keys?
         // TODO should items and conditions not be empty?
@@ -1233,15 +1092,15 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
         assert!(
             matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
-            && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[0].fingerprint.unwrap() == fingerprint0
+            && keys[1].fingerprint.unwrap() == fingerprint1)
         );
 
         assert!(
@@ -1265,7 +1124,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1273,8 +1132,8 @@ mod test {
 
         assert!(
             matches!(&policy.item, Multisig { keys, threshold } if threshold == &1
-            && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[0].fingerprint.unwrap() == fingerprint0
+            && keys[1].fingerprint.unwrap() == fingerprint1)
         );
         assert!(
             matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
@@ -1297,7 +1156,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1305,8 +1164,8 @@ mod test {
 
         assert!(
             matches!(&policy.item, Multisig { keys, threshold } if threshold == &2
-            && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[0].fingerprint.unwrap() == fingerprint0
+            && keys[1].fingerprint.unwrap() == fingerprint1)
         );
 
         assert!(
@@ -1330,13 +1189,15 @@ mod test {
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
         let single_key = wallet_desc.derive(0);
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
+        assert!(
+            matches!(&policy.item, Signature(pk_or_f) if pk_or_f.fingerprint.unwrap() == fingerprint)
+        );
         assert!(matches!(&policy.contribution, Satisfaction::None));
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
@@ -1344,13 +1205,15 @@ mod test {
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
         let single_key = wallet_desc.derive(0);
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
+        assert!(
+            matches!(&policy.item, Signature(pk_or_f) if pk_or_f.fingerprint.unwrap() == fingerprint)
+        );
         assert!(
             matches!(&policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
         );
@@ -1369,7 +1232,7 @@ mod test {
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
         let single_key = wallet_desc.derive(0);
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = single_key
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1377,8 +1240,8 @@ mod test {
 
         assert!(
             matches!(&policy.item, Multisig { keys, threshold } if threshold == &1
-            && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[0].fingerprint.unwrap() == fingerprint0
+            && keys[1].fingerprint.unwrap() == fingerprint1)
         );
         assert!(
             matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
@@ -1412,7 +1275,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1451,7 +1314,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1476,7 +1339,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1494,7 +1357,7 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
         let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
@@ -1516,10 +1379,10 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers = keymap.into();
 
         let policy = wallet_desc
-            .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
+            .extract_policy(&signers, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
@@ -1582,7 +1445,7 @@ mod test {
             addr.to_string()
         );
 
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
 
         let psbt = Psbt::from_str(ALICE_SIGNED_PSBT).unwrap();
 
@@ -1638,19 +1501,19 @@ mod test {
         let (prvkey_bob, _, _) = setup_keys(BOB_TPRV_STR, ALICE_BOB_PATH, &secp);
 
         let desc =
-            descriptor!(wsh(thresh(2,n:d:v:older(2),s:pk(prvkey_alice),s:pk(prvkey_bob)))).unwrap();
+            descriptor!(wsh(thresh(2,d:v:older(2),s:pk(prvkey_alice),s:pk(prvkey_bob)))).unwrap();
 
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
 
         let addr = wallet_desc
             .as_derived(0, &secp)
             .address(Network::Testnet)
             .unwrap();
         assert_eq!(
-            "tb1qsydsey4hexagwkvercqsmes6yet0ndkyt6uzcphtqnygjd8hmzmsfxrv58",
+            "tb1qhpemaacpeu8ajlnh8k9v55ftg0px58r8630fz8t5mypxcwdk5d8sum522g",
             addr.to_string()
         );
 
@@ -1731,185 +1594,9 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
+        let signers_container = Arc::new(SignersContainer::from(keymap));
 
         let policy = wallet_desc.extract_policy(&signers_container, BuildSatisfaction::None, &secp);
         assert!(policy.is_ok());
     }
-
-    #[test]
-    fn test_extract_tr_key_spend() {
-        let secp = Secp256k1::new();
-
-        let (prvkey, _, fingerprint) = setup_keys(ALICE_TPRV_STR, ALICE_BOB_PATH, &secp);
-
-        let desc = descriptor!(tr(prvkey)).unwrap();
-        let (wallet_desc, keymap) = desc
-            .into_wallet_descriptor(&secp, Network::Testnet)
-            .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
-
-        let policy = wallet_desc
-            .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
-            .unwrap();
-        assert_eq!(
-            policy,
-            Some(Policy {
-                id: "48u0tz0n".to_string(),
-                item: SatisfiableItem::SchnorrSignature(PkOrF::Fingerprint(fingerprint)),
-                satisfaction: Satisfaction::None,
-                contribution: Satisfaction::Complete {
-                    condition: Condition::default()
-                }
-            })
-        );
-    }
-
-    #[test]
-    fn test_extract_tr_script_spend() {
-        let secp = Secp256k1::new();
-
-        let (alice_prv, _, alice_fing) = setup_keys(ALICE_TPRV_STR, ALICE_BOB_PATH, &secp);
-        let (_, bob_pub, bob_fing) = setup_keys(BOB_TPRV_STR, ALICE_BOB_PATH, &secp);
-
-        let desc = descriptor!(tr(bob_pub, pk(alice_prv))).unwrap();
-        let (wallet_desc, keymap) = desc
-            .into_wallet_descriptor(&secp, Network::Testnet)
-            .unwrap();
-        let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
-
-        let policy = wallet_desc
-            .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
-            .unwrap()
-            .unwrap();
-
-        assert!(
-            matches!(policy.item, SatisfiableItem::Thresh { ref items, threshold: 1 } if items.len() == 2)
-        );
-        assert!(
-            matches!(policy.contribution, Satisfaction::PartialComplete { n: 2, m: 1, items, .. } if items == vec![1])
-        );
-
-        let alice_sig = SatisfiableItem::SchnorrSignature(PkOrF::Fingerprint(alice_fing));
-        let bob_sig = SatisfiableItem::SchnorrSignature(PkOrF::Fingerprint(bob_fing));
-
-        let thresh_items = match policy.item {
-            SatisfiableItem::Thresh { items, .. } => items,
-            _ => unreachable!(),
-        };
-
-        assert_eq!(thresh_items[0].item, bob_sig);
-        assert_eq!(thresh_items[1].item, alice_sig);
-    }
-
-    #[test]
-    fn test_extract_tr_satisfaction_key_spend() {
-        const UNSIGNED_PSBT: &str = "cHNidP8BAFMBAAAAAUKgMCqtGLSiGYhsTols2UJ/VQQgQi/SXO38uXs2SahdAQAAAAD/////ARyWmAAAAAAAF6kU4R3W8CnGzZcSsaovTYu0X8vHt3WHAAAAAAABASuAlpgAAAAAACJRIEiEBFjbZa1xdjLfFjrKzuC1F1LeRyI/gL6IuGKNmUuSIRYnkGTDxwXMHP32fkDFoGJY28trxbkkVgR2z7jZa2pOJA0AyRF8LgAAAIADAAAAARcgJ5Bkw8cFzBz99n5AxaBiWNvLa8W5JFYEds+42WtqTiQAAA==";
-        const SIGNED_PSBT: &str = "cHNidP8BAFMBAAAAAUKgMCqtGLSiGYhsTols2UJ/VQQgQi/SXO38uXs2SahdAQAAAAD/////ARyWmAAAAAAAF6kU4R3W8CnGzZcSsaovTYu0X8vHt3WHAAAAAAABASuAlpgAAAAAACJRIEiEBFjbZa1xdjLfFjrKzuC1F1LeRyI/gL6IuGKNmUuSARNAIsRvARpRxuyQosVA7guRQT9vXr+S25W2tnP2xOGBsSgq7A4RL8yrbvwDmNlWw9R0Nc/6t+IsyCyy7dD/lbUGgyEWJ5Bkw8cFzBz99n5AxaBiWNvLa8W5JFYEds+42WtqTiQNAMkRfC4AAACAAwAAAAEXICeQZMPHBcwc/fZ+QMWgYljby2vFuSRWBHbPuNlrak4kAAA=";
-
-        let unsigned_psbt = Psbt::from_str(UNSIGNED_PSBT).unwrap();
-        let signed_psbt = Psbt::from_str(SIGNED_PSBT).unwrap();
-
-        let secp = Secp256k1::new();
-
-        let (_, pubkey, _) = setup_keys(ALICE_TPRV_STR, ALICE_BOB_PATH, &secp);
-
-        let desc = descriptor!(tr(pubkey)).unwrap();
-        let (wallet_desc, _) = desc
-            .into_wallet_descriptor(&secp, Network::Testnet)
-            .unwrap();
-
-        let policy_unsigned = wallet_desc
-            .extract_policy(
-                &SignersContainer::default(),
-                BuildSatisfaction::Psbt(&unsigned_psbt),
-                &secp,
-            )
-            .unwrap()
-            .unwrap();
-        let policy_signed = wallet_desc
-            .extract_policy(
-                &SignersContainer::default(),
-                BuildSatisfaction::Psbt(&signed_psbt),
-                &secp,
-            )
-            .unwrap()
-            .unwrap();
-
-        assert_eq!(policy_unsigned.satisfaction, Satisfaction::None);
-        assert_eq!(
-            policy_signed.satisfaction,
-            Satisfaction::Complete {
-                condition: Default::default()
-            }
-        );
-    }
-
-    #[test]
-    fn test_extract_tr_satisfaction_script_spend() {
-        const UNSIGNED_PSBT: &str = "cHNidP8BAFMBAAAAAWZalxaErOL7P3WPIUc8DsjgE68S+ww+uqiqEI2SAwlPAAAAAAD/////AQiWmAAAAAAAF6kU4R3W8CnGzZcSsaovTYu0X8vHt3WHAAAAAAABASuAlpgAAAAAACJRINa6bLPZwp3/CYWoxyI3mLYcSC5f9LInAMUng94nspa2IhXBgiPY+kcolS1Hp0niOK/+7VHz6F+nsz8JVxnzWzkgToYjIHhGyuexxtRVKevRx4YwWR/W0r7LPHt6oS6DLlzyuYQarMAhFnhGyuexxtRVKevRx4YwWR/W0r7LPHt6oS6DLlzyuYQaLQH2onWFc3UR6I9ZhuHVeJCi5LNAf4APVd7mHn4BhdViHRwu7j4AAACAAgAAACEWgiPY+kcolS1Hp0niOK/+7VHz6F+nsz8JVxnzWzkgToYNAMkRfC4AAACAAgAAAAEXIIIj2PpHKJUtR6dJ4jiv/u1R8+hfp7M/CVcZ81s5IE6GARgg9qJ1hXN1EeiPWYbh1XiQouSzQH+AD1Xe5h5+AYXVYh0AAA==";
-        const SIGNED_PSBT: &str = "cHNidP8BAFMBAAAAAWZalxaErOL7P3WPIUc8DsjgE68S+ww+uqiqEI2SAwlPAAAAAAD/////AQiWmAAAAAAAF6kU4R3W8CnGzZcSsaovTYu0X8vHt3WHAAAAAAABASuAlpgAAAAAACJRINa6bLPZwp3/CYWoxyI3mLYcSC5f9LInAMUng94nspa2AQcAAQhCAUALcP9w/+Ddly9DWdhHTnQ9uCDWLPZjR6vKbKePswW2Ee6W5KNfrklus/8z98n7BQ1U4vADHk0FbadeeL8rrbHlARNAC3D/cP/g3ZcvQ1nYR050Pbgg1iz2Y0erymynj7MFthHuluSjX65JbrP/M/fJ+wUNVOLwAx5NBW2nXni/K62x5UEUeEbK57HG1FUp69HHhjBZH9bSvss8e3qhLoMuXPK5hBr2onWFc3UR6I9ZhuHVeJCi5LNAf4APVd7mHn4BhdViHUAXNmWieJ80Fs+PMa2C186YOBPZbYG/ieEUkagMwzJ788SoCucNdp5wnxfpuJVygFhglDrXGzujFtC82PrMohwuIhXBgiPY+kcolS1Hp0niOK/+7VHz6F+nsz8JVxnzWzkgToYjIHhGyuexxtRVKevRx4YwWR/W0r7LPHt6oS6DLlzyuYQarMAhFnhGyuexxtRVKevRx4YwWR/W0r7LPHt6oS6DLlzyuYQaLQH2onWFc3UR6I9ZhuHVeJCi5LNAf4APVd7mHn4BhdViHRwu7j4AAACAAgAAACEWgiPY+kcolS1Hp0niOK/+7VHz6F+nsz8JVxnzWzkgToYNAMkRfC4AAACAAgAAAAEXIIIj2PpHKJUtR6dJ4jiv/u1R8+hfp7M/CVcZ81s5IE6GARgg9qJ1hXN1EeiPWYbh1XiQouSzQH+AD1Xe5h5+AYXVYh0AAA==";
-
-        let unsigned_psbt = Psbt::from_str(UNSIGNED_PSBT).unwrap();
-        let signed_psbt = Psbt::from_str(SIGNED_PSBT).unwrap();
-
-        let secp = Secp256k1::new();
-
-        let (_, alice_pub, _) = setup_keys(ALICE_TPRV_STR, ALICE_BOB_PATH, &secp);
-        let (_, bob_pub, _) = setup_keys(BOB_TPRV_STR, ALICE_BOB_PATH, &secp);
-
-        let desc = descriptor!(tr(bob_pub, pk(alice_pub))).unwrap();
-        let (wallet_desc, _) = desc
-            .into_wallet_descriptor(&secp, Network::Testnet)
-            .unwrap();
-
-        let policy_unsigned = wallet_desc
-            .extract_policy(
-                &SignersContainer::default(),
-                BuildSatisfaction::Psbt(&unsigned_psbt),
-                &secp,
-            )
-            .unwrap()
-            .unwrap();
-        let policy_signed = wallet_desc
-            .extract_policy(
-                &SignersContainer::default(),
-                BuildSatisfaction::Psbt(&signed_psbt),
-                &secp,
-            )
-            .unwrap()
-            .unwrap();
-
-        assert!(
-            matches!(policy_unsigned.item, SatisfiableItem::Thresh { ref items, threshold: 1 } if items.len() == 2)
-        );
-        assert!(
-            matches!(policy_unsigned.satisfaction, Satisfaction::Partial { n: 2, m: 1, items, .. } if items.is_empty())
-        );
-
-        assert!(
-            matches!(policy_signed.item, SatisfiableItem::Thresh { ref items, threshold: 1 } if items.len() == 2)
-        );
-        assert!(
-            matches!(policy_signed.satisfaction, Satisfaction::PartialComplete { n: 2, m: 1, items, .. } if items == vec![0, 1])
-        );
-
-        let satisfied_items = match policy_signed.item {
-            SatisfiableItem::Thresh { items, .. } => items,
-            _ => unreachable!(),
-        };
-
-        assert_eq!(
-            satisfied_items[0].satisfaction,
-            Satisfaction::Complete {
-                condition: Default::default()
-            }
-        );
-        assert_eq!(
-            satisfied_items[1].satisfaction,
-            Satisfaction::Complete {
-                condition: Default::default()
-            }
-        );
-    }
 }

src/descriptor/template.rs

@@ -40,19 +40,18 @@ pub type DescriptorTemplateOut = (ExtendedDescriptor, KeyMap, ValidNetworks);
 /// use bdk::keys::{IntoDescriptorKey, KeyError};
 /// use bdk::miniscript::Legacy;
 /// use bdk::template::{DescriptorTemplate, DescriptorTemplateOut};
-/// use bitcoin::Network;
 ///
 /// struct MyP2PKH<K: IntoDescriptorKey<Legacy>>(K);
 ///
 /// impl<K: IntoDescriptorKey<Legacy>> DescriptorTemplate for MyP2PKH<K> {
-///     fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
+///     fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
 ///         Ok(bdk::descriptor!(pkh(self.0))?)
 ///     }
 /// }
 /// ```
 pub trait DescriptorTemplate {
     /// Build the complete descriptor
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError>;
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError>;
 }
 
 /// Turns a [`DescriptorTemplate`] into a valid wallet descriptor by calling its
@@ -63,7 +62,7 @@ impl<T: DescriptorTemplate> IntoWalletDescriptor for T {
         secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        self.build(network)?.into_wallet_descriptor(secp, network)
+        self.build()?.into_wallet_descriptor(secp, network)
     }
 }
 
@@ -96,7 +95,7 @@ impl<T: DescriptorTemplate> IntoWalletDescriptor for T {
 pub struct P2Pkh<K: IntoDescriptorKey<Legacy>>(pub K);
 
 impl<K: IntoDescriptorKey<Legacy>> DescriptorTemplate for P2Pkh<K> {
-    fn build(self, _network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
         descriptor!(pkh(self.0))
     }
 }
@@ -131,7 +130,7 @@ impl<K: IntoDescriptorKey<Legacy>> DescriptorTemplate for P2Pkh<K> {
 pub struct P2Wpkh_P2Sh<K: IntoDescriptorKey<Segwitv0>>(pub K);
 
 impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh_P2Sh<K> {
-    fn build(self, _network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
         descriptor!(sh(wpkh(self.0)))
     }
 }
@@ -165,12 +164,12 @@ impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh_P2Sh<K> {
 pub struct P2Wpkh<K: IntoDescriptorKey<Segwitv0>>(pub K);
 
 impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh<K> {
-    fn build(self, _network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
         descriptor!(wpkh(self.0))
     }
 }
 
-/// BIP44 template. Expands to `pkh(key/44'/{0,1}'/0'/{0,1}/*)`
+/// BIP44 template. Expands to `pkh(key/44'/0'/0'/{0,1}/*)`
 ///
 /// Since there are hardened derivation steps, this template requires a private derivable key (generally a `xprv`/`tprv`).
 ///
@@ -194,21 +193,21 @@ impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh<K> {
 ///     MemoryDatabase::default()
 /// )?;
 ///
-/// assert_eq!(wallet.get_address(New)?.to_string(), "mmogjc7HJEZkrLqyQYqJmxUqFaC7i4uf89");
-/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "pkh([c55b303f/44'/1'/0']tpubDCuorCpzvYS2LCD75BR46KHE8GdDeg1wsAgNZeNr6DaB5gQK1o14uErKwKLuFmeemkQ6N2m3rNgvctdJLyr7nwu2yia7413Hhg8WWE44cgT/0/*)#5wrnv0xt");
+/// assert_eq!(wallet.get_address(New)?.to_string(), "miNG7dJTzJqNbFS19svRdTCisC65dsubtR");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "pkh([c55b303f/44'/0'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)#xgaaevjx");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 pub struct Bip44<K: DerivableKey<Legacy>>(pub K, pub KeychainKind);
 
 impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Pkh(legacy::make_bipxx_private(44, self.0, self.1, network)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Pkh(legacy::make_bipxx_private(44, self.0, self.1)?).build()
     }
 }
 
 /// BIP44 public template. Expands to `pkh(key/{0,1}/*)`
 ///
-/// This assumes that the key used has already been derived with `m/44'/0'/0'` for Mainnet or `m/44'/1'/0'` for Testnet.
+/// This assumes that the key used has already been derived with `m/44'/0'/0'`.
 ///
 /// This template requires the parent fingerprint to populate correctly the metadata of PSBTs.
 ///
@@ -241,12 +240,12 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
 pub struct Bip44Public<K: DerivableKey<Legacy>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
 
 impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44Public<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Pkh(legacy::make_bipxx_public(44, self.0, self.1, self.2)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Pkh(legacy::make_bipxx_public(44, self.0, self.1, self.2)?).build()
     }
 }
 
-/// BIP49 template. Expands to `sh(wpkh(key/49'/{0,1}'/0'/{0,1}/*))`
+/// BIP49 template. Expands to `sh(wpkh(key/49'/0'/0'/{0,1}/*))`
 ///
 /// Since there are hardened derivation steps, this template requires a private derivable key (generally a `xprv`/`tprv`).
 ///
@@ -270,15 +269,15 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44Public<K> {
 ///     MemoryDatabase::default()
 /// )?;
 ///
-/// assert_eq!(wallet.get_address(New)?.to_string(), "2N4zkWAoGdUv4NXhSsU8DvS5MB36T8nKHEB");
-/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49'/1'/0']tpubDDYr4kdnZgjjShzYNjZUZXUUtpXaofdkMaipyS8ThEh45qFmhT4hKYways7UXmg6V7het1QiFo9kf4kYUXyDvV4rHEyvSpys9pjCB3pukxi/0/*))#s9vxlc8e");
+/// assert_eq!(wallet.get_address(New)?.to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))#gsmdv4xr");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 pub struct Bip49<K: DerivableKey<Segwitv0>>(pub K, pub KeychainKind);
 
 impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Wpkh_P2Sh(segwit_v0::make_bipxx_private(49, self.0, self.1, network)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Wpkh_P2Sh(segwit_v0::make_bipxx_private(49, self.0, self.1)?).build()
     }
 }
 
@@ -311,18 +310,18 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
 /// )?;
 ///
 /// assert_eq!(wallet.get_address(New)?.to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
-/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49'/0'/0']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))#gsmdv4xr");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))#gsmdv4xr");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 pub struct Bip49Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
 
 impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49Public<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Wpkh_P2Sh(segwit_v0::make_bipxx_public(49, self.0, self.1, self.2)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Wpkh_P2Sh(segwit_v0::make_bipxx_public(49, self.0, self.1, self.2)?).build()
     }
 }
 
-/// BIP84 template. Expands to `wpkh(key/84'/{0,1}'/0'/{0,1}/*)`
+/// BIP84 template. Expands to `wpkh(key/84'/0'/0'/{0,1}/*)`
 ///
 /// Since there are hardened derivation steps, this template requires a private derivable key (generally a `xprv`/`tprv`).
 ///
@@ -346,15 +345,15 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49Public<K> {
 ///     MemoryDatabase::default()
 /// )?;
 ///
-/// assert_eq!(wallet.get_address(New)?.to_string(), "tb1qhl85z42h7r4su5u37rvvw0gk8j2t3n9y7zsg4n");
-/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "wpkh([c55b303f/84'/1'/0']tpubDDc5mum24DekpNw92t6fHGp8Gr2JjF9J7i4TZBtN6Vp8xpAULG5CFaKsfugWa5imhrQQUZKXe261asP5koDHo5bs3qNTmf3U3o4v9SaB8gg/0/*)#6kfecsmr");
+/// assert_eq!(wallet.get_address(New)?.to_string(), "tb1qedg9fdlf8cnnqfd5mks6uz5w4kgpk2pr6y4qc7");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "wpkh([c55b303f/84\'/0\'/0\']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)#nkk5dtkg");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 pub struct Bip84<K: DerivableKey<Segwitv0>>(pub K, pub KeychainKind);
 
 impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Wpkh(segwit_v0::make_bipxx_private(84, self.0, self.1, network)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Wpkh(segwit_v0::make_bipxx_private(84, self.0, self.1)?).build()
     }
 }
 
@@ -393,8 +392,8 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 pub struct Bip84Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
 
 impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84Public<K> {
-    fn build(self, network: Network) -> Result<DescriptorTemplateOut, DescriptorError> {
-        P2Wpkh(segwit_v0::make_bipxx_public(84, self.0, self.1, self.2)?).build(network)
+    fn build(self) -> Result<DescriptorTemplateOut, DescriptorError> {
+        P2Wpkh(segwit_v0::make_bipxx_public(84, self.0, self.1, self.2)?).build()
     }
 }
 
@@ -407,19 +406,10 @@ macro_rules! expand_make_bipxx {
                 bip: u32,
                 key: K,
                 keychain: KeychainKind,
-                network: Network,
             ) -> Result<impl IntoDescriptorKey<$ctx>, DescriptorError> {
                 let mut derivation_path = Vec::with_capacity(4);
                 derivation_path.push(bip32::ChildNumber::from_hardened_idx(bip)?);
-
-                match network {
-                    Network::Bitcoin => {
-                        derivation_path.push(bip32::ChildNumber::from_hardened_idx(0)?);
-                    }
-                    _ => {
-                        derivation_path.push(bip32::ChildNumber::from_hardened_idx(1)?);
-                    }
-                }
+                derivation_path.push(bip32::ChildNumber::from_hardened_idx(0)?);
                 derivation_path.push(bip32::ChildNumber::from_hardened_idx(0)?);
 
                 match keychain {
@@ -476,40 +466,6 @@ mod test {
     use miniscript::descriptor::{DescriptorPublicKey, DescriptorTrait, KeyMap};
     use miniscript::Descriptor;
 
-    // BIP44 `pkh(key/44'/{0,1}'/0'/{0,1}/*)`
-    #[test]
-    fn test_bip44_template_cointype() {
-        use bitcoin::util::bip32::ChildNumber::{self, Hardened};
-
-        let xprvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K2fpbqApQL69a4oKdGVnVN52R82Ft7d1pSqgKmajF62acJo3aMszZb6qQ22QsVECSFxvf9uyxFUvFYQMq3QbtwtRSMjLAhMf").unwrap();
-        assert_eq!(Network::Bitcoin, xprvkey.network);
-        let xdesc = Bip44(xprvkey, KeychainKind::Internal)
-            .build(Network::Bitcoin)
-            .unwrap();
-
-        if let ExtendedDescriptor::Pkh(pkh) = xdesc.0 {
-            let path: Vec<ChildNumber> = pkh.into_inner().full_derivation_path().into();
-            let purpose = path.get(0).unwrap();
-            assert!(matches!(purpose, Hardened { index: 44 }));
-            let coin_type = path.get(1).unwrap();
-            assert!(matches!(coin_type, Hardened { index: 0 }));
-        }
-
-        let tprvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
-        assert_eq!(Network::Testnet, tprvkey.network);
-        let tdesc = Bip44(tprvkey, KeychainKind::Internal)
-            .build(Network::Testnet)
-            .unwrap();
-
-        if let ExtendedDescriptor::Pkh(pkh) = tdesc.0 {
-            let path: Vec<ChildNumber> = pkh.into_inner().full_derivation_path().into();
-            let purpose = path.get(0).unwrap();
-            assert!(matches!(purpose, Hardened { index: 44 }));
-            let coin_type = path.get(1).unwrap();
-            assert!(matches!(coin_type, Hardened { index: 1 }));
-        }
-    }
-
     // verify template descriptor generates expected address(es)
     fn check(
         desc: Result<(Descriptor<DescriptorPublicKey>, KeyMap, ValidNetworks), DescriptorError>,
@@ -541,7 +497,7 @@ mod test {
             bitcoin::PrivateKey::from_wif("cTc4vURSzdx6QE6KVynWGomDbLaA75dNALMNyfjh3p8DRRar84Um")
                 .unwrap();
         check(
-            P2Pkh(prvkey).build(Network::Bitcoin),
+            P2Pkh(prvkey).build(),
             false,
             true,
             &["mwJ8hxFYW19JLuc65RCTaP4v1rzVU8cVMT"],
@@ -552,7 +508,7 @@ mod test {
         )
         .unwrap();
         check(
-            P2Pkh(pubkey).build(Network::Bitcoin),
+            P2Pkh(pubkey).build(),
             false,
             true,
             &["muZpTpBYhxmRFuCjLc7C6BBDF32C8XVJUi"],
@@ -566,7 +522,7 @@ mod test {
             bitcoin::PrivateKey::from_wif("cTc4vURSzdx6QE6KVynWGomDbLaA75dNALMNyfjh3p8DRRar84Um")
                 .unwrap();
         check(
-            P2Wpkh_P2Sh(prvkey).build(Network::Bitcoin),
+            P2Wpkh_P2Sh(prvkey).build(),
             true,
             true,
             &["2NB4ox5VDRw1ecUv6SnT3VQHPXveYztRqk5"],
@@ -577,7 +533,7 @@ mod test {
         )
         .unwrap();
         check(
-            P2Wpkh_P2Sh(pubkey).build(Network::Bitcoin),
+            P2Wpkh_P2Sh(pubkey).build(),
             true,
             true,
             &["2N5LiC3CqzxDamRTPG1kiNv1FpNJQ7x28sb"],
@@ -591,7 +547,7 @@ mod test {
             bitcoin::PrivateKey::from_wif("cTc4vURSzdx6QE6KVynWGomDbLaA75dNALMNyfjh3p8DRRar84Um")
                 .unwrap();
         check(
-            P2Wpkh(prvkey).build(Network::Bitcoin),
+            P2Wpkh(prvkey).build(),
             true,
             true,
             &["bcrt1q4525hmgw265tl3drrl8jjta7ayffu6jfcwxx9y"],
@@ -602,7 +558,7 @@ mod test {
         )
         .unwrap();
         check(
-            P2Wpkh(pubkey).build(Network::Bitcoin),
+            P2Wpkh(pubkey).build(),
             true,
             true,
             &["bcrt1qngw83fg8dz0k749cg7k3emc7v98wy0c7azaa6h"],
@@ -614,7 +570,7 @@ mod test {
     fn test_bip44_template() {
         let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         check(
-            Bip44(prvkey, KeychainKind::External).build(Network::Bitcoin),
+            Bip44(prvkey, KeychainKind::External).build(),
             false,
             false,
             &[
@@ -624,7 +580,7 @@ mod test {
             ],
         );
         check(
-            Bip44(prvkey, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip44(prvkey, KeychainKind::Internal).build(),
             false,
             false,
             &[
@@ -641,7 +597,7 @@ mod test {
         let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU").unwrap();
         let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
         check(
-            Bip44Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
+            Bip44Public(pubkey, fingerprint, KeychainKind::External).build(),
             false,
             false,
             &[
@@ -651,7 +607,7 @@ mod test {
             ],
         );
         check(
-            Bip44Public(pubkey, fingerprint, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip44Public(pubkey, fingerprint, KeychainKind::Internal).build(),
             false,
             false,
             &[
@@ -667,7 +623,7 @@ mod test {
     fn test_bip49_template() {
         let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         check(
-            Bip49(prvkey, KeychainKind::External).build(Network::Bitcoin),
+            Bip49(prvkey, KeychainKind::External).build(),
             true,
             false,
             &[
@@ -677,7 +633,7 @@ mod test {
             ],
         );
         check(
-            Bip49(prvkey, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip49(prvkey, KeychainKind::Internal).build(),
             true,
             false,
             &[
@@ -694,7 +650,7 @@ mod test {
         let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L").unwrap();
         let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
         check(
-            Bip49Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
+            Bip49Public(pubkey, fingerprint, KeychainKind::External).build(),
             true,
             false,
             &[
@@ -704,7 +660,7 @@ mod test {
             ],
         );
         check(
-            Bip49Public(pubkey, fingerprint, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip49Public(pubkey, fingerprint, KeychainKind::Internal).build(),
             true,
             false,
             &[
@@ -720,7 +676,7 @@ mod test {
     fn test_bip84_template() {
         let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
         check(
-            Bip84(prvkey, KeychainKind::External).build(Network::Bitcoin),
+            Bip84(prvkey, KeychainKind::External).build(),
             true,
             false,
             &[
@@ -730,7 +686,7 @@ mod test {
             ],
         );
         check(
-            Bip84(prvkey, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip84(prvkey, KeychainKind::Internal).build(),
             true,
             false,
             &[
@@ -747,7 +703,7 @@ mod test {
         let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q").unwrap();
         let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
         check(
-            Bip84Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
+            Bip84Public(pubkey, fingerprint, KeychainKind::External).build(),
             true,
             false,
             &[
@@ -757,7 +713,7 @@ mod test {
             ],
         );
         check(
-            Bip84Public(pubkey, fingerprint, KeychainKind::Internal).build(Network::Bitcoin),
+            Bip84Public(pubkey, fingerprint, KeychainKind::Internal).build(),
             true,
             false,
             &[

src/keys/bip39.rs

@@ -19,7 +19,7 @@ use bitcoin::Network;
 
 use miniscript::ScriptContext;
 
-pub use bip39::{Error, Language, Mnemonic};
+pub use bip39::{Language, Mnemonic};
 
 type Seed = [u8; 64];
 
@@ -94,23 +94,6 @@ impl<Ctx: ScriptContext> DerivableKey<Ctx> for MnemonicWithPassphrase {
     }
 }
 
-#[cfg_attr(docsrs, doc(cfg(feature = "keys-bip39")))]
-impl<Ctx: ScriptContext> DerivableKey<Ctx> for (GeneratedKey<Mnemonic, Ctx>, Option<String>) {
-    fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
-        let (mnemonic, passphrase) = self;
-        (mnemonic.into_key(), passphrase).into_extended_key()
-    }
-
-    fn into_descriptor_key(
-        self,
-        source: Option<bip32::KeySource>,
-        derivation_path: bip32::DerivationPath,
-    ) -> Result<DescriptorKey<Ctx>, KeyError> {
-        let (mnemonic, passphrase) = self;
-        (mnemonic.into_key(), passphrase).into_descriptor_key(source, derivation_path)
-    }
-}
-
 #[cfg_attr(docsrs, doc(cfg(feature = "keys-bip39")))]
 impl<Ctx: ScriptContext> DerivableKey<Ctx> for Mnemonic {
     fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {

src/keys/mod.rs

@@ -20,12 +20,12 @@ use std::str::FromStr;
 use bitcoin::secp256k1::{self, Secp256k1, Signing};
 
 use bitcoin::util::bip32;
-use bitcoin::{Network, PrivateKey, PublicKey, XOnlyPublicKey};
+use bitcoin::{Network, PrivateKey, PublicKey};
 
 use miniscript::descriptor::{Descriptor, DescriptorXKey, Wildcard};
 pub use miniscript::descriptor::{
     DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePriv, DescriptorSinglePub, KeyMap,
-    SinglePubKey, SortedMultiVec,
+    SortedMultiVec,
 };
 pub use miniscript::ScriptContext;
 use miniscript::{Miniscript, Terminal};
@@ -127,8 +127,6 @@ pub enum ScriptContextEnum {
     Legacy,
     /// Segwitv0 scripts
     Segwitv0,
-    /// Taproot scripts
-    Tap,
 }
 
 impl ScriptContextEnum {
@@ -141,11 +139,6 @@ impl ScriptContextEnum {
     pub fn is_segwit_v0(&self) -> bool {
         self == &ScriptContextEnum::Segwitv0
     }
-
-    /// Returns whether the script context is [`ScriptContextEnum::Tap`]
-    pub fn is_taproot(&self) -> bool {
-        self == &ScriptContextEnum::Tap
-    }
 }
 
 /// Trait that adds extra useful methods to [`ScriptContext`]s
@@ -162,11 +155,6 @@ pub trait ExtScriptContext: ScriptContext {
     fn is_segwit_v0() -> bool {
         Self::as_enum().is_segwit_v0()
     }
-
-    /// Returns whether the script context is [`Tap`](miniscript::Tap), aka Taproot or Segwit V1
-    fn is_taproot() -> bool {
-        Self::as_enum().is_taproot()
-    }
 }
 
 impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
@@ -174,7 +162,6 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
         match TypeId::of::<Ctx>() {
             t if t == TypeId::of::<miniscript::Legacy>() => ScriptContextEnum::Legacy,
             t if t == TypeId::of::<miniscript::Segwitv0>() => ScriptContextEnum::Segwitv0,
-            t if t == TypeId::of::<miniscript::Tap>() => ScriptContextEnum::Tap,
             _ => unimplemented!("Unknown ScriptContext type"),
         }
     }
@@ -225,7 +212,7 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 ///
 /// use bdk::keys::{
 ///     mainnet_network, DescriptorKey, DescriptorPublicKey, DescriptorSinglePub,
-///     IntoDescriptorKey, KeyError, ScriptContext, SinglePubKey,
+///     IntoDescriptorKey, KeyError, ScriptContext,
 /// };
 ///
 /// pub struct MyKeyType {
@@ -237,7 +224,7 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 ///         Ok(DescriptorKey::from_public(
 ///             DescriptorPublicKey::SinglePub(DescriptorSinglePub {
 ///                 origin: None,
-///                 key: SinglePubKey::FullKey(self.pubkey),
+///                 key: self.pubkey,
 ///             }),
 ///             mainnet_network(),
 ///         ))
@@ -332,6 +319,7 @@ impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
         match self {
             ExtendedKey::Private((mut xprv, _)) => {
                 xprv.network = network;
+                xprv.private_key.network = network;
                 Some(xprv)
             }
             ExtendedKey::Public(_) => None,
@@ -346,7 +334,7 @@ impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
         secp: &Secp256k1<C>,
     ) -> bip32::ExtendedPubKey {
         let mut xpub = match self {
-            ExtendedKey::Private((xprv, _)) => bip32::ExtendedPubKey::from_priv(secp, &xprv),
+            ExtendedKey::Private((xprv, _)) => bip32::ExtendedPubKey::from_private(secp, &xprv),
             ExtendedKey::Public((xpub, _)) => xpub,
         };
 
@@ -400,7 +388,7 @@ impl<Ctx: ScriptContext> From<bip32::ExtendedPrivKey> for ExtendedKey<Ctx> {
 ///             network: self.network,
 ///             depth: 0,
 ///             parent_fingerprint: bip32::Fingerprint::default(),
-///             private_key: self.key_data.inner,
+///             private_key: self.key_data,
 ///             chain_code: bip32::ChainCode::from(self.chain_code.as_ref()),
 ///             child_number: bip32::ChildNumber::Normal { index: 0 },
 ///         };
@@ -432,7 +420,7 @@ impl<Ctx: ScriptContext> From<bip32::ExtendedPrivKey> for ExtendedKey<Ctx> {
 ///             network: bitcoin::Network::Bitcoin, // pick an arbitrary network here
 ///             depth: 0,
 ///             parent_fingerprint: bip32::Fingerprint::default(),
-///             private_key: self.key_data.inner,
+///             private_key: self.key_data,
 ///             chain_code: bip32::ChainCode::from(self.chain_code.as_ref()),
 ///             child_number: bip32::ChildNumber::Normal { index: 0 },
 ///         };
@@ -560,16 +548,6 @@ impl<K, Ctx: ScriptContext> Deref for GeneratedKey<K, Ctx> {
     }
 }
 
-impl<K: Clone, Ctx: ScriptContext> Clone for GeneratedKey<K, Ctx> {
-    fn clone(&self) -> GeneratedKey<K, Ctx> {
-        GeneratedKey {
-            key: self.key.clone(),
-            valid_networks: self.valid_networks.clone(),
-            phantom: self.phantom,
-        }
-    }
-}
-
 // Make generated "derivable" keys themselves "derivable". Also make sure they are assigned the
 // right `valid_networks`.
 impl<Ctx, K> DerivableKey<Ctx> for GeneratedKey<K, Ctx>
@@ -710,11 +688,11 @@ impl<Ctx: ScriptContext> GeneratableKey<Ctx> for PrivateKey {
         entropy: Self::Entropy,
     ) -> Result<GeneratedKey<Self, Ctx>, Self::Error> {
         // pick a arbitrary network here, but say that we support all of them
-        let inner = secp256k1::SecretKey::from_slice(&entropy)?;
+        let key = secp256k1::SecretKey::from_slice(&entropy)?;
         let private_key = PrivateKey {
             compressed: options.compressed,
             network: Network::Bitcoin,
-            inner,
+            key,
         };
 
         Ok(GeneratedKey::new(private_key, any_network()))
@@ -792,18 +770,13 @@ pub fn make_pkh<Pk: IntoDescriptorKey<Ctx>, Ctx: ScriptContext>(
 
 // Used internally by `bdk::fragment!` to build `multi()` fragments
 #[doc(hidden)]
-pub fn make_multi<
-    Pk: IntoDescriptorKey<Ctx>,
-    Ctx: ScriptContext,
-    V: Fn(usize, Vec<DescriptorPublicKey>) -> Terminal<DescriptorPublicKey, Ctx>,
->(
+pub fn make_multi<Pk: IntoDescriptorKey<Ctx>, Ctx: ScriptContext>(
     thresh: usize,
-    variant: V,
     pks: Vec<Pk>,
     secp: &SecpCtx,
 ) -> Result<(Miniscript<DescriptorPublicKey, Ctx>, KeyMap, ValidNetworks), DescriptorError> {
     let (pks, key_map, valid_networks) = expand_multi_keys(pks, secp)?;
-    let minisc = Miniscript::from_ast(variant(thresh, pks))?;
+    let minisc = Miniscript::from_ast(Terminal::Multi(thresh, pks))?;
 
     minisc.check_miniscript()?;
 
@@ -858,17 +831,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for DescriptorPublicKey {
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for PublicKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-            key: SinglePubKey::FullKey(self),
-            origin: None,
-        })
-        .into_descriptor_key()
-    }
-}
-
-impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for XOnlyPublicKey {
-    fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-            key: SinglePubKey::XOnly(self),
+            key: self,
             origin: None,
         })
         .into_descriptor_key()
@@ -970,6 +933,29 @@ pub mod test {
         );
     }
 
+    #[test]
+    fn test_keys_wif_network() {
+        // test mainnet wif
+        let generated_xprv: GeneratedKey<_, miniscript::Segwitv0> =
+            bip32::ExtendedPrivKey::generate_with_entropy_default(TEST_ENTROPY).unwrap();
+        let xkey = generated_xprv.into_extended_key().unwrap();
+
+        let network = Network::Bitcoin;
+        let xprv = xkey.into_xprv(network).unwrap();
+        let wif = PrivateKey::from_wif(&xprv.private_key.to_wif()).unwrap();
+        assert_eq!(wif.network, network);
+
+        // test testnet wif
+        let generated_xprv: GeneratedKey<_, miniscript::Segwitv0> =
+            bip32::ExtendedPrivKey::generate_with_entropy_default(TEST_ENTROPY).unwrap();
+        let xkey = generated_xprv.into_extended_key().unwrap();
+
+        let network = Network::Testnet;
+        let xprv = xkey.into_xprv(network).unwrap();
+        let wif = PrivateKey::from_wif(&xprv.private_key.to_wif()).unwrap();
+        assert_eq!(wif.network, network);
+    }
+
     #[cfg(feature = "keys-bip39")]
     #[test]
     fn test_keys_wif_network_bip39() {
@@ -981,7 +967,8 @@ pub mod test {
         .into_extended_key()
         .unwrap();
         let xprv = xkey.into_xprv(Network::Testnet).unwrap();
+        let wif = PrivateKey::from_wif(&xprv.private_key.to_wif()).unwrap();
 
-        assert_eq!(xprv.network, Network::Testnet);
+        assert_eq!(wif.network, Network::Testnet);
     }
 }

src/lib.rs

@@ -44,15 +44,14 @@
 //! interact with the bitcoin P2P network.
 //!
 //! ```toml
-//! bdk = "0.20.0"
+//! bdk = "0.15.0"
 //! ```
-//!
-//! # Examples
 #![cfg_attr(
     feature = "electrum",
     doc = r##"
 ## Sync the balance of a descriptor
 
+### Example
 ```no_run
 use bdk::{Wallet, SyncOptions};
 use bdk::database::MemoryDatabase;
@@ -81,6 +80,7 @@ fn main() -> Result<(), bdk::Error> {
 //!
 //! ## Generate a few addresses
 //!
+//! ### Example
 //! ```
 //! use bdk::{Wallet};
 //! use bdk::database::MemoryDatabase;
@@ -106,6 +106,7 @@ fn main() -> Result<(), bdk::Error> {
     doc = r##"
 ## Create a transaction
 
+### Example
 ```no_run
 use bdk::{FeeRate, Wallet, SyncOptions};
 use bdk::database::MemoryDatabase;
@@ -149,6 +150,7 @@ fn main() -> Result<(), bdk::Error> {
 //!
 //! ## Sign a transaction
 //!
+//! ### Example
 //! ```no_run
 //! use std::str::FromStr;
 //!
@@ -190,7 +192,7 @@ fn main() -> Result<(), bdk::Error> {
 //! * `async-interface`: async functions in bdk traits
 //! * `keys-bip39`: [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) mnemonic codes for generating deterministic keys
 //!
-//! # Internal features
+//! ## Internal features
 //!
 //! These features do not expose any new API, but influence internal implementation aspects of
 //! BDK.
@@ -249,14 +251,6 @@ pub extern crate sled;
 #[cfg(feature = "sqlite")]
 pub extern crate rusqlite;
 
-// We should consider putting this under a feature flag but we need the macro in doctests so we need
-// to wait until https://github.com/rust-lang/rust/issues/67295 is fixed.
-//
-// Stuff in here is too rough to document atm
-#[doc(hidden)]
-#[macro_use]
-pub mod testutils;
-
 #[allow(unused_imports)]
 #[macro_use]
 pub(crate) mod error;
@@ -285,3 +279,10 @@ pub use wallet::Wallet;
 pub fn version() -> &'static str {
     env!("CARGO_PKG_VERSION", "unknown")
 }
+
+// We should consider putting this under a feature flag but we need the macro in doctests so we need
+// to wait until https://github.com/rust-lang/rust/issues/67295 is fixed.
+//
+// Stuff in here is too rough to document atm
+#[doc(hidden)]
+pub mod testutils;

src/psbt/mod.rs

@@ -19,7 +19,7 @@ pub trait PsbtUtils {
 impl PsbtUtils for Psbt {
     #[allow(clippy::all)] // We want to allow `manual_map` but it is too new.
     fn get_utxo_for(&self, input_index: usize) -> Option<TxOut> {
-        let tx = &self.unsigned_tx;
+        let tx = &self.global.unsigned_tx;
 
         if input_index >= tx.input.len() {
             return None;
@@ -93,7 +93,7 @@ mod test {
         let mut builder = wallet.build_tx();
         builder.add_recipient(send_to.script_pubkey(), 10_000);
         let (mut psbt, _) = builder.finish().unwrap();
-        psbt.unsigned_tx.input.push(TxIn::default());
+        psbt.global.unsigned_tx.input.push(TxIn::default());
         let options = SignOptions {
             trust_witness_utxo: true,
             ..Default::default()
@@ -112,9 +112,10 @@ mod test {
 
         // add a finalized input
         psbt.inputs.push(psbt_bip.inputs[0].clone());
-        psbt.unsigned_tx
+        psbt.global
+            .unsigned_tx
             .input
-            .push(psbt_bip.unsigned_tx.input[0].clone());
+            .push(psbt_bip.global.unsigned_tx.input[0].clone());
 
         let _ = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
     }

src/testutils/blockchain_tests.rs

@@ -2,7 +2,7 @@ use crate::testutils::TestIncomingTx;
 use bitcoin::consensus::encode::{deserialize, serialize};
 use bitcoin::hashes::hex::{FromHex, ToHex};
 use bitcoin::hashes::sha256d;
-use bitcoin::{Address, Amount, Script, Transaction, Txid, Witness};
+use bitcoin::{Address, Amount, Script, Transaction, Txid};
 pub use bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
 pub use bitcoincore_rpc::{Auth, Client as RpcClient, RpcApi};
 use core::str::FromStr;
@@ -90,19 +90,13 @@ impl TestClient {
             map.insert(out.to_address.clone(), Amount::from_sat(out.value));
         }
 
-        let input: Vec<_> = meta_tx
-            .input
-            .into_iter()
-            .map(|x| x.into_raw_tx_input())
-            .collect();
-
         if self.get_balance(None, None).unwrap() < Amount::from_sat(required_balance) {
             panic!("Insufficient funds in bitcoind. Please generate a few blocks with: `bitcoin-cli generatetoaddress 10 {}`", self.get_new_address(None, None).unwrap());
         }
 
         // FIXME: core can't create a tx with two outputs to the same address
         let tx = self
-            .create_raw_transaction_hex(&input, &map, meta_tx.locktime, meta_tx.replaceable)
+            .create_raw_transaction_hex(&[], &map, meta_tx.locktime, meta_tx.replaceable)
             .unwrap();
         let tx = self.fund_raw_transaction(tx, None, None).unwrap();
         let mut tx: Transaction = deserialize(&tx.hex).unwrap();
@@ -193,7 +187,7 @@ impl TestClient {
                 previous_output: OutPoint::null(),
                 script_sig: Builder::new().push_int(height).into_script(),
                 sequence: 0xFFFFFFFF,
-                witness: Witness::from_vec(vec![witness_reserved_value]),
+                witness: vec![witness_reserved_value],
             }],
             output: vec![],
         };
@@ -203,31 +197,23 @@ impl TestClient {
 
         let mut block = Block { header, txdata };
 
-        if let Some(witness_root) = block.witness_root() {
-            let witness_commitment = Block::compute_witness_commitment(
-                &witness_root,
-                &coinbase_tx.input[0]
-                    .witness
-                    .last()
-                    .expect("Should contain the witness reserved value"),
-            );
+        let witness_root = block.witness_root();
+        let witness_commitment =
+            Block::compute_witness_commitment(&witness_root, &coinbase_tx.input[0].witness[0]);
 
-            // now update and replace the coinbase tx
-            let mut coinbase_witness_commitment_script = vec![0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
-            coinbase_witness_commitment_script.extend_from_slice(&witness_commitment);
-
-            coinbase_tx.output.push(TxOut {
-                value: 0,
-                script_pubkey: coinbase_witness_commitment_script.into(),
-            });
-        }
+        // now update and replace the coinbase tx
+        let mut coinbase_witness_commitment_script = vec![0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
+        coinbase_witness_commitment_script.extend_from_slice(&witness_commitment);
 
+        coinbase_tx.output.push(TxOut {
+            value: 0,
+            script_pubkey: coinbase_witness_commitment_script.into(),
+        });
         block.txdata[0] = coinbase_tx;
 
         // set merkle root
-        if let Some(merkle_root) = block.compute_merkle_root() {
-            block.header.merkle_root = merkle_root;
-        }
+        let merkle_root = block.merkle_root();
+        block.header.merkle_root = merkle_root;
 
         assert!(block.check_merkle_root());
         assert!(block.check_witness_commitment());
@@ -328,7 +314,7 @@ impl Default for TestClient {
     fn default() -> Self {
         let bitcoind_exe = env::var("BITCOIND_EXE")
             .ok()
-            .or(bitcoind::downloaded_exe_path().ok())
+            .or(bitcoind::downloaded_exe_path())
             .expect(
                 "you should provide env var BITCOIND_EXE or specifiy a bitcoind version feature",
             );
@@ -367,12 +353,11 @@ macro_rules! bdk_blockchain_tests {
      fn $_fn_name:ident ( $( $test_client:ident : &TestClient )? $(,)? ) -> $blockchain:ty $block:block) => {
         #[cfg(test)]
         mod bdk_blockchain_tests {
-            use $crate::bitcoin::{Transaction, Network};
+            use $crate::bitcoin::Network;
             use $crate::testutils::blockchain_tests::TestClient;
             use $crate::blockchain::Blockchain;
             use $crate::database::MemoryDatabase;
             use $crate::types::KeychainKind;
-            use $crate::wallet::AddressIndex;
             use $crate::{Wallet, FeeRate, SyncOptions};
             use $crate::testutils;
 
@@ -388,34 +373,11 @@ macro_rules! bdk_blockchain_tests {
                 Wallet::new(&descriptors.0.to_string(), descriptors.1.as_ref(), Network::Regtest, MemoryDatabase::new()).unwrap()
             }
 
-            #[allow(dead_code)]
-            enum WalletType {
-                WpkhSingleSig,
-                TaprootKeySpend,
-                TaprootScriptSpend,
-                TaprootScriptSpend2,
-                TaprootScriptSpend3,
-            }
-
-            fn init_wallet(ty: WalletType) -> (Wallet<MemoryDatabase>, $blockchain, (String, Option<String>), TestClient) {
+            fn init_single_sig() -> (Wallet<MemoryDatabase>, $blockchain, (String, Option<String>), TestClient) {
                 let _ = env_logger::try_init();
 
-                let descriptors = match ty {
-                    WalletType::WpkhSingleSig => testutils! {
-                        @descriptors ( "wpkh(Alice)" ) ( "wpkh(Alice)" ) ( @keys ( "Alice" => (@generate_xprv "/44'/0'/0'/0/*", "/44'/0'/0'/1/*") ) )
-                    },
-                    WalletType::TaprootKeySpend => testutils! {
-                        @descriptors ( "tr(Alice)" ) ( "tr(Alice)" ) ( @keys ( "Alice" => (@generate_xprv "/44'/0'/0'/0/*", "/44'/0'/0'/1/*") ) )
-                    },
-                    WalletType::TaprootScriptSpend => testutils! {
-                        @descriptors ( "tr(Key,and_v(v:pk(Script),older(6)))" ) ( "tr(Key,and_v(v:pk(Script),older(6)))" ) ( @keys ( "Key" => (@literal "30e14486f993d5a2d222770e97286c56cec5af115e1fb2e0065f476a0fcf8788"), "Script" => (@generate_xprv "/0/*", "/1/*") ) )
-                    },
-                    WalletType::TaprootScriptSpend2 => testutils! {
-                        @descriptors ( "tr(Alice,pk(Bob))" ) ( "tr(Alice,pk(Bob))" ) ( @keys ( "Alice" => (@literal "30e14486f993d5a2d222770e97286c56cec5af115e1fb2e0065f476a0fcf8788"), "Bob" => (@generate_xprv "/0/*", "/1/*") ) )
-                    },
-                    WalletType::TaprootScriptSpend3 => testutils! {
-                        @descriptors ( "tr(Alice,{pk(Bob),pk(Carol)})" ) ( "tr(Alice,{pk(Bob),pk(Carol)})" ) ( @keys ( "Alice" => (@literal "30e14486f993d5a2d222770e97286c56cec5af115e1fb2e0065f476a0fcf8788"), "Bob" => (@generate_xprv "/0/*", "/1/*"), "Carol" => (@generate_xprv "/0/*", "/1/*") ) )
-                    },
+                let descriptors = testutils! {
+                    @descriptors ( "wpkh(Alice)" ) ( "wpkh(Alice)" ) ( @keys ( "Alice" => (@generate_xprv "/44'/0'/0'/0/*", "/44'/0'/0'/1/*") ) )
                 };
 
                 let test_client = TestClient::default();
@@ -423,16 +385,12 @@ macro_rules! bdk_blockchain_tests {
                 let wallet = get_wallet_from_descriptors(&descriptors);
 
                 // rpc need to call import_multi before receiving any tx, otherwise will not see tx in the mempool
-                #[cfg(any(feature = "test-rpc", feature = "test-rpc-legacy"))]
+                #[cfg(feature = "test-rpc")]
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
                 (wallet, blockchain, descriptors, test_client)
             }
 
-            fn init_single_sig() -> (Wallet<MemoryDatabase>, $blockchain, (String, Option<String>), TestClient) {
-                init_wallet(WalletType::WpkhSingleSig)
-            }
-
             #[test]
             fn test_sync_simple() {
                 use std::ops::Deref;
@@ -448,7 +406,7 @@ macro_rules! bdk_blockchain_tests {
 
                 // the RPC blockchain needs to call `sync()` during initialization to import the
                 // addresses (see `init_single_sig()`), so we skip this assertion
-                #[cfg(not(any(feature = "test-rpc", feature = "test-rpc-legacy")))]
+                #[cfg(not(feature = "test-rpc"))]
                 assert!(wallet.database().deref().get_sync_time().unwrap().is_none(), "initial sync_time not none");
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -652,66 +610,12 @@ macro_rules! bdk_blockchain_tests {
                 assert_eq!(wallet.list_unspent().unwrap().len(), 1, "incorrect number of unspents");
             }
 
-            // Syncing wallet should not result in wallet address index to decrement.
-            // This is critical as we should always ensure to not reuse addresses.
-            #[test]
-            fn test_sync_address_index_should_not_decrement() {
-                let (wallet, blockchain, _descriptors, mut test_client) = init_single_sig();
-
-                const ADDRS_TO_FUND: u32 = 7;
-                const ADDRS_TO_IGNORE: u32 = 11;
-
-                let mut first_addr_index: u32 = 0;
-
-                (0..ADDRS_TO_FUND + ADDRS_TO_IGNORE).for_each(|i| {
-                    let new_addr = wallet.get_address(AddressIndex::New).unwrap();
-
-                    if i == 0 {
-                        first_addr_index = new_addr.index;
-                    }
-                    assert_eq!(new_addr.index, i+first_addr_index, "unexpected new address index (before sync)");
-
-                    if i < ADDRS_TO_FUND {
-                        test_client.receive(testutils! {
-                            @tx ((@addr new_addr.address) => 50_000)
-                        });
-                    }
-                });
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-
-                let new_addr = wallet.get_address(AddressIndex::New).unwrap();
-                assert_eq!(new_addr.index, ADDRS_TO_FUND+ADDRS_TO_IGNORE+first_addr_index, "unexpected new address index (after sync)");
-            }
-
-            // Even if user does not explicitly grab new addresses, the address index should
-            // increment after sync (if wallet has a balance).
-            #[test]
-            fn test_sync_address_index_should_increment() {
-                let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
-
-                const START_FUND: u32 = 4;
-                const END_FUND: u32 = 20;
-
-                // "secretly" fund wallet via given range
-                (START_FUND..END_FUND).for_each(|addr_index| {
-                    test_client.receive(testutils! {
-                        @tx ((@external descriptors, addr_index) => 50_000)
-                    });
-                });
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-
-                let address = wallet.get_address(AddressIndex::New).unwrap();
-                assert_eq!(address.index, END_FUND, "unexpected new address index (after sync)");
-            }
-
             /// Send two conflicting transactions to the same address twice in a row.
             /// The coins should only be received once!
             #[test]
             fn test_sync_double_receive() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
-                let receiver_wallet = get_wallet_from_descriptors(&("wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)".to_string(), None));
+                                let receiver_wallet = get_wallet_from_descriptors(&("wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)".to_string(), None));
                 // need to sync so rpc can start watching
                 receiver_wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -719,15 +623,15 @@ macro_rules! bdk_blockchain_tests {
                     @tx ( (@external descriptors, 0) => 50_000, (@external descriptors, 1) => 25_000 ) (@confirmations 1)
                 });
 
-                wallet.sync(&blockchain, SyncOptions::default()).expect("sync");
+                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap(), 75_000, "incorrect balance");
                 let target_addr = receiver_wallet.get_address($crate::wallet::AddressIndex::New).unwrap().address;
 
                 let tx1 = {
                     let mut builder = wallet.build_tx();
                     builder.add_recipient(target_addr.script_pubkey(), 49_000).enable_rbf();
-                    let (mut psbt, _details) = builder.finish().expect("building first tx");
-                    let finalized = wallet.sign(&mut psbt, Default::default()).expect("signing first tx");
+                    let (mut psbt, _details) = builder.finish().unwrap();
+                    let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
                     assert!(finalized, "Cannot finalize transaction");
                     psbt.extract_tx()
                 };
@@ -735,17 +639,17 @@ macro_rules! bdk_blockchain_tests {
                 let tx2 = {
                     let mut builder = wallet.build_tx();
                     builder.add_recipient(target_addr.script_pubkey(), 49_000).enable_rbf().fee_rate(FeeRate::from_sat_per_vb(5.0));
-                    let (mut psbt, _details) = builder.finish().expect("building replacement tx");
-                    let finalized = wallet.sign(&mut psbt, Default::default()).expect("signing replacement tx");
+                    let (mut psbt, _details) = builder.finish().unwrap();
+                    let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
                     assert!(finalized, "Cannot finalize transaction");
                     psbt.extract_tx()
                 };
 
-                blockchain.broadcast(&tx1).expect("broadcasting first");
-                blockchain.broadcast(&tx2).expect("broadcasting replacement");
+                blockchain.broadcast(&tx1).unwrap();
+                blockchain.broadcast(&tx2).unwrap();
 
-                receiver_wallet.sync(&blockchain, SyncOptions::default()).expect("syncing receiver");
-                assert_eq!(receiver_wallet.get_balance().expect("balance"), 49_000, "should have received coins once and only once");
+                receiver_wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+                assert_eq!(receiver_wallet.get_balance().unwrap(), 49_000, "should have received coins once and only once");
             }
 
             #[test]
@@ -907,7 +811,7 @@ macro_rules! bdk_blockchain_tests {
 
                 let mut builder = wallet.build_fee_bump(details.txid).unwrap();
                 builder.fee_rate(FeeRate::from_sat_per_vb(2.1));
-                let (mut new_psbt, new_details) = builder.finish().expect("fee bump tx");
+                let (mut new_psbt, new_details) = builder.finish().unwrap();
                 let finalized = wallet.sign(&mut new_psbt, Default::default()).unwrap();
                 assert!(finalized, "Cannot finalize transaction");
                 blockchain.broadcast(&new_psbt.extract_tx()).unwrap();
@@ -989,7 +893,7 @@ macro_rules! bdk_blockchain_tests {
             #[test]
             fn test_sync_bump_fee_add_input_no_change() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
-                let node_addr = test_client.get_node_address(None);
+                                let node_addr = test_client.get_node_address(None);
 
                 test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000, (@external descriptors, 1) => 25_000 ) (@confirmations 1)
@@ -1077,7 +981,6 @@ macro_rules! bdk_blockchain_tests {
             }
 
             #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
             fn test_send_to_bech32m_addr() {
                 use std::str::FromStr;
                 use serde;
@@ -1172,279 +1075,6 @@ macro_rules! bdk_blockchain_tests {
                 let taproot_balance = taproot_wallet_client.get_balance(None, None).unwrap();
                 assert_eq!(taproot_balance.as_sat(), 25_000, "node has incorrect taproot wallet balance");
             }
-
-            #[test]
-            fn test_tx_chain() {
-                use bitcoincore_rpc::RpcApi;
-                use bitcoin::consensus::encode::deserialize;
-                use $crate::wallet::AddressIndex;
-
-                // Here we want to test that we set correctly the send and receive
-                // fields in the transaction object. For doing so, we create two
-                // different txs, the second one spending from the first:
-                // 1.
-                // Core (#1) -> Core (#2)
-                //           -> Us   (#3)
-                // 2.
-                // Core (#2) -> Us   (#4)
-
-                let (wallet, blockchain, _, mut test_client) = init_single_sig();
-                let bdk_address = wallet.get_address(AddressIndex::New).unwrap().address;
-                let core_address = test_client.get_new_address(None, None).unwrap();
-                let tx = testutils! {
-                    @tx ( (@addr bdk_address.clone()) => 50_000, (@addr core_address.clone()) => 40_000 )
-                };
-
-                // Tx one: from Core #1 to Core #2 and Us #3.
-                let txid_1 = test_client.receive(tx);
-                let tx_1: Transaction = deserialize(&test_client.get_transaction(&txid_1, None).unwrap().hex).unwrap();
-                let vout_1 = tx_1.output.into_iter().position(|o| o.script_pubkey == core_address.script_pubkey()).unwrap() as u32;
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                let tx_1 = wallet.list_transactions(false).unwrap().into_iter().find(|tx| tx.txid == txid_1).unwrap();
-                assert_eq!(tx_1.received, 50_000);
-                assert_eq!(tx_1.sent, 0);
-
-                // Tx two: from Core #2 to Us #4.
-                let tx = testutils! {
-                    @tx ( (@addr bdk_address) => 10_000 ) ( @inputs (txid_1,vout_1))
-                };
-                let txid_2 = test_client.receive(tx);
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                let tx_2 = wallet.list_transactions(false).unwrap().into_iter().find(|tx| tx.txid == txid_2).unwrap();
-                assert_eq!(tx_2.received, 10_000);
-                assert_eq!(tx_2.sent, 0);
-            }
-
-            #[test]
-            fn test_double_spend() {
-                // We create a tx and then we try to double spend it; BDK will always allow
-                // us to do so, as it never forgets about spent UTXOs
-                let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
-                let node_addr = test_client.get_node_address(None);
-                let _ = test_client.receive(testutils! {
-                    @tx ( (@external descriptors, 0) => 50_000 )
-                });
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                let mut builder = wallet.build_tx();
-                builder.add_recipient(node_addr.script_pubkey(), 25_000);
-                let (mut psbt, _details) = builder.finish().unwrap();
-                let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-                assert!(finalized, "Cannot finalize transaction");
-                let initial_tx = psbt.extract_tx();
-                let _sent_txid = blockchain.broadcast(&initial_tx).unwrap();
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                for utxo in wallet.list_unspent().unwrap() {
-                    // Making sure the TXO we just spent is not returned by list_unspent
-                    assert!(utxo.outpoint != initial_tx.input[0].previous_output, "wallet displays spent txo in unspents");
-                }
-                // We can still create a transaction double spending `initial_tx`
-                let mut builder = wallet.build_tx();
-                builder
-                    .add_utxo(initial_tx.input[0].previous_output)
-                    .expect("Can't manually add an UTXO spent");
-                test_client.generate(1, Some(node_addr));
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                // Even after confirmation, we can still create a tx double spend it
-                let mut builder = wallet.build_tx();
-                builder
-                    .add_utxo(initial_tx.input[0].previous_output)
-                    .expect("Can't manually add an UTXO spent");
-                for utxo in wallet.list_unspent().unwrap() {
-                    // Making sure the TXO we just spent is not returned by list_unspent
-                    assert!(utxo.outpoint != initial_tx.input[0].previous_output, "wallet displays spent txo in unspents");
-                }
-            }
-
-            #[test]
-            fn test_send_receive_pkh() {
-                let descriptors = ("pkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)".to_string(), None);
-                let mut test_client = TestClient::default();
-                let blockchain = get_blockchain(&test_client);
-
-                let wallet = get_wallet_from_descriptors(&descriptors);
-                #[cfg(any(feature = "test-rpc", feature = "test-rpc-legacy"))]
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-
-                let _ = test_client.receive(testutils! {
-                    @tx ( (@external descriptors, 0)   => 50_000 )
-                });
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-
-                assert_eq!(wallet.get_balance().unwrap(), 50_000);
-
-                let tx = {
-                    let mut builder = wallet.build_tx();
-                    builder.add_recipient(test_client.get_node_address(None).script_pubkey(), 25_000);
-                    let (mut psbt, _details) = builder.finish().unwrap();
-                    wallet.sign(&mut psbt, Default::default()).unwrap();
-                    psbt.extract_tx()
-                };
-                blockchain.broadcast(&tx).unwrap();
-
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-            }
-
-            #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_taproot_key_spend() {
-                let (wallet, blockchain, descriptors, mut test_client) = init_wallet(WalletType::TaprootKeySpend);
-
-                let _ = test_client.receive(testutils! {
-                    @tx ( (@external descriptors, 0) => 50_000 )
-                });
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                assert_eq!(wallet.get_balance().unwrap(), 50_000);
-
-                let tx = {
-                    let mut builder = wallet.build_tx();
-                    builder.add_recipient(test_client.get_node_address(None).script_pubkey(), 25_000);
-                    let (mut psbt, _details) = builder.finish().unwrap();
-                    wallet.sign(&mut psbt, Default::default()).unwrap();
-                    psbt.extract_tx()
-                };
-                blockchain.broadcast(&tx).unwrap();
-            }
-
-            #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_taproot_script_spend() {
-                let (wallet, blockchain, descriptors, mut test_client) = init_wallet(WalletType::TaprootScriptSpend);
-
-                let _ = test_client.receive(testutils! {
-                    @tx ( (@external descriptors, 0) => 50_000 ) ( @confirmations 6 )
-                });
-                wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-                assert_eq!(wallet.get_balance().unwrap(), 50_000);
-
-                let ext_policy = wallet.policies(KeychainKind::External).unwrap().unwrap();
-                let int_policy = wallet.policies(KeychainKind::Internal).unwrap().unwrap();
-
-                let ext_path = vec![(ext_policy.id.clone(), vec![1])].into_iter().collect();
-                let int_path = vec![(int_policy.id.clone(), vec![1])].into_iter().collect();
-
-                let tx = {
-                    let mut builder = wallet.build_tx();
-                    builder.add_recipient(test_client.get_node_address(None).script_pubkey(), 25_000)
-                        .policy_path(ext_path, KeychainKind::External)
-                        .policy_path(int_path, KeychainKind::Internal);
-                    let (mut psbt, _details) = builder.finish().unwrap();
-                    wallet.sign(&mut psbt, Default::default()).unwrap();
-                    psbt.extract_tx()
-                };
-                blockchain.broadcast(&tx).unwrap();
-            }
-
-            #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_sign_taproot_core_keyspend_psbt() {
-                test_sign_taproot_core_psbt(WalletType::TaprootKeySpend);
-            }
-
-            #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_sign_taproot_core_scriptspend2_psbt() {
-                test_sign_taproot_core_psbt(WalletType::TaprootScriptSpend2);
-            }
-
-            #[test]
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_sign_taproot_core_scriptspend3_psbt() {
-                test_sign_taproot_core_psbt(WalletType::TaprootScriptSpend3);
-            }
-
-            #[cfg(not(feature = "test-rpc-legacy"))]
-            fn test_sign_taproot_core_psbt(wallet_type: WalletType) {
-                use std::str::FromStr;
-                use serde_json;
-                use bitcoincore_rpc::jsonrpc::serde_json::Value;
-                use bitcoincore_rpc::{Auth, Client, RpcApi};
-
-                let (wallet, _blockchain, _descriptors, test_client) = init_wallet(wallet_type);
-
-                // TODO replace once rust-bitcoincore-rpc with PR 174 released
-                // https://github.com/rust-bitcoin/rust-bitcoincore-rpc/pull/174
-                let _createwallet_result: Value = test_client.bitcoind.client.call("createwallet", &["taproot_wallet".into(), true.into(), true.into(), serde_json::to_value("").unwrap(), false.into(), true.into(), true.into(), false.into()]).expect("created wallet");
-
-                let external_descriptor = wallet.get_descriptor_for_keychain(KeychainKind::External);
-
-                // TODO replace once bitcoind released with support for rust-bitcoincore-rpc PR 174
-                let taproot_wallet_client = Client::new(&test_client.bitcoind.rpc_url_with_wallet("taproot_wallet"), Auth::CookieFile(test_client.bitcoind.params.cookie_file.clone())).unwrap();
-
-                let descriptor_info = taproot_wallet_client.get_descriptor_info(external_descriptor.to_string().as_str()).expect("descriptor info");
-
-                let import_descriptor_args = json!([{
-                    "desc": descriptor_info.descriptor,
-                    "active": true,
-                    "timestamp": "now",
-                    "label":"taproot key spend",
-                }]);
-                let _importdescriptors_result: Value = taproot_wallet_client.call("importdescriptors", &[import_descriptor_args]).expect("import wallet");
-                let generate_to_address: bitcoin::Address = taproot_wallet_client.call("getnewaddress", &["test address".into(), "bech32m".into()]).expect("new address");
-                let _generatetoaddress_result = taproot_wallet_client.generate_to_address(101, &generate_to_address).expect("generated to address");
-                let send_to_address = wallet.get_address($crate::wallet::AddressIndex::New).unwrap().address.to_string();
-                let change_address = wallet.get_address($crate::wallet::AddressIndex::New).unwrap().address.to_string();
-                let send_addr_amounts = json!([{
-                    send_to_address: "0.4321"
-                }]);
-                let send_options = json!({
-                    "change_address": change_address,
-                    "psbt": true,
-                });
-                let send_result: Value = taproot_wallet_client.call("send", &[send_addr_amounts, Value::Null, "unset".into(), Value::Null, send_options]).expect("send psbt");
-                let core_psbt = send_result["psbt"].as_str().expect("core psbt str");
-
-                use bitcoin::util::psbt::PartiallySignedTransaction;
-
-                // Test parsing core created PSBT
-                let mut psbt = PartiallySignedTransaction::from_str(&core_psbt).expect("core taproot psbt");
-
-                // Test signing core created PSBT
-                let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-                assert_eq!(finalized, true);
-
-                // Test with updated psbt
-                let update_result: Value = taproot_wallet_client.call("utxoupdatepsbt", &[core_psbt.into()]).expect("update psbt utxos");
-                let core_updated_psbt = update_result.as_str().expect("core updated psbt");
-
-                // Test parsing core created and updated PSBT
-                let mut psbt = PartiallySignedTransaction::from_str(&core_updated_psbt).expect("core taproot psbt");
-
-                // Test signing core created and updated PSBT
-                let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-                assert_eq!(finalized, true);
-            }
-
-            #[test]
-            fn test_get_block_hash() {
-                use bitcoincore_rpc::{ RpcApi };
-                use crate::blockchain::GetBlockHash;
-
-                // create wallet with init_wallet
-                let (_, blockchain, _descriptors, mut test_client) = init_single_sig();
-
-                let height = test_client.bitcoind.client.get_blockchain_info().unwrap().blocks as u64;
-                let best_hash = test_client.bitcoind.client.get_best_block_hash().unwrap();
-
-                // use get_block_hash to get best block hash and compare with best_hash above
-                let block_hash = blockchain.get_block_hash(height).unwrap();
-                assert_eq!(best_hash, block_hash);
-
-                // generate blocks to address
-                let node_addr = test_client.get_node_address(None);
-                test_client.generate(10, Some(node_addr));
-
-                let height = test_client.bitcoind.client.get_blockchain_info().unwrap().blocks as u64;
-                let best_hash = test_client.bitcoind.client.get_best_block_hash().unwrap();
-
-                let block_hash = blockchain.get_block_hash(height).unwrap();
-                assert_eq!(best_hash, block_hash);
-
-                // try to get hash for block that has not yet been created.
-                assert!(blockchain.get_block_hash(height + 1).is_err());
-            }
         }
     };
 

src/testutils/configurable_blockchain_tests.rs

@@ -1,140 +0,0 @@
-use bitcoin::Network;
-
-use crate::{
-    blockchain::ConfigurableBlockchain, database::MemoryDatabase, testutils, wallet::AddressIndex,
-    Wallet,
-};
-
-use super::blockchain_tests::TestClient;
-
-/// Trait for testing [`ConfigurableBlockchain`] implementations.
-pub trait ConfigurableBlockchainTester<B: ConfigurableBlockchain>: Sized {
-    /// Blockchain name for logging.
-    const BLOCKCHAIN_NAME: &'static str;
-
-    /// Generates a blockchain config with a given stop_gap.
-    ///
-    /// If this returns [`Option::None`], then the associated tests will not run.
-    fn config_with_stop_gap(
-        &self,
-        _test_client: &mut TestClient,
-        _stop_gap: usize,
-    ) -> Option<B::Config> {
-        None
-    }
-
-    /// Runs all avaliable tests.
-    fn run(&self) {
-        let test_client = &mut TestClient::default();
-
-        if self.config_with_stop_gap(test_client, 0).is_some() {
-            test_wallet_sync_with_stop_gaps(test_client, self);
-        } else {
-            println!(
-                "{}: Skipped tests requiring config_with_stop_gap.",
-                Self::BLOCKCHAIN_NAME
-            );
-        }
-    }
-}
-
-/// Test whether blockchain implementation syncs with expected behaviour given different `stop_gap`
-/// parameters.
-///
-/// For each test vector:
-/// * Fill wallet's derived addresses with balances (as specified by test vector).
-///    * [0..addrs_before]          => 1000sats for each address
-///    * [addrs_before..actual_gap] => empty addresses
-///    * [actual_gap..addrs_after]  => 1000sats for each address
-/// * Then, perform wallet sync and obtain wallet balance
-/// * Check balance is within expected range (we can compare `stop_gap` and `actual_gap` to
-///    determine this).
-fn test_wallet_sync_with_stop_gaps<T, B>(test_client: &mut TestClient, tester: &T)
-where
-    T: ConfigurableBlockchainTester<B>,
-    B: ConfigurableBlockchain,
-{
-    // Generates wallet descriptor
-    let descriptor_of_account = |account_index: usize| -> String {
-        format!("wpkh([c258d2e4/84h/1h/0h]tpubDDYkZojQFQjht8Tm4jsS3iuEmKjTiEGjG6KnuFNKKJb5A6ZUCUZKdvLdSDWofKi4ToRCwb9poe1XdqfUnP4jaJjCB2Zwv11ZLgSbnZSNecE/{account_index}/*)")
-    };
-
-    // Amount (in satoshis) provided to a single address (which expects to have a balance)
-    const AMOUNT_PER_TX: u64 = 1000;
-
-    // [stop_gap, actual_gap, addrs_before, addrs_after]
-    //
-    // [0]     stop_gap: Passed to [`ElectrumBlockchainConfig`]
-    // [1]   actual_gap: Range size of address indexes without a balance
-    // [2] addrs_before: Range size of address indexes (before gap) which contains a balance
-    // [3]  addrs_after: Range size of address indexes (after gap) which contains a balance
-    let test_vectors: Vec<[u64; 4]> = vec![
-        [0, 0, 0, 5],
-        [0, 0, 5, 5],
-        [0, 1, 5, 5],
-        [0, 2, 5, 5],
-        [1, 0, 5, 5],
-        [1, 1, 5, 5],
-        [1, 2, 5, 5],
-        [2, 1, 5, 5],
-        [2, 2, 5, 5],
-        [2, 3, 5, 5],
-    ];
-
-    for (account_index, vector) in test_vectors.into_iter().enumerate() {
-        let [stop_gap, actual_gap, addrs_before, addrs_after] = vector;
-        let descriptor = descriptor_of_account(account_index);
-
-        let blockchain = B::from_config(
-            &tester
-                .config_with_stop_gap(test_client, stop_gap as _)
-                .unwrap(),
-        )
-        .unwrap();
-
-        let wallet =
-            Wallet::new(&descriptor, None, Network::Regtest, MemoryDatabase::new()).unwrap();
-
-        // fill server-side with txs to specified address indexes
-        // return the max balance of the wallet (also the actual balance)
-        let max_balance = (0..addrs_before)
-            .chain(addrs_before + actual_gap..addrs_before + actual_gap + addrs_after)
-            .fold(0_u64, |sum, i| {
-                let address = wallet.get_address(AddressIndex::Peek(i as _)).unwrap();
-                test_client.receive(testutils! {
-                    @tx ( (@addr address.address) => AMOUNT_PER_TX )
-                });
-                sum + AMOUNT_PER_TX
-            });
-
-        // minimum allowed balance of wallet (based on stop gap)
-        let min_balance = if actual_gap > stop_gap {
-            addrs_before * AMOUNT_PER_TX
-        } else {
-            max_balance
-        };
-
-        // perform wallet sync
-        wallet.sync(&blockchain, Default::default()).unwrap();
-
-        let wallet_balance = wallet.get_balance().unwrap();
-
-        let details = format!(
-            "test_vector: [stop_gap: {}, actual_gap: {}, addrs_before: {}, addrs_after: {}]",
-            stop_gap, actual_gap, addrs_before, addrs_after,
-        );
-        assert!(
-            wallet_balance <= max_balance,
-            "wallet balance is greater than received amount: {}",
-            details
-        );
-        assert!(
-            wallet_balance >= min_balance,
-            "wallet balance is smaller than expected: {}",
-            details
-        );
-
-        // generate block to confirm new transactions
-        test_client.generate(1, None);
-    }
-}

src/testutils/mod.rs

@@ -14,37 +14,11 @@
 #[cfg(feature = "test-blockchains")]
 pub mod blockchain_tests;
 
-#[cfg(test)]
-#[cfg(feature = "test-blockchains")]
-pub mod configurable_blockchain_tests;
+use bitcoin::secp256k1::{Secp256k1, Verification};
+use bitcoin::{Address, PublicKey};
 
-use bitcoin::{Address, Txid};
-
-#[derive(Clone, Debug)]
-pub struct TestIncomingInput {
-    pub txid: Txid,
-    pub vout: u32,
-    pub sequence: Option<u32>,
-}
-
-impl TestIncomingInput {
-    pub fn new(txid: Txid, vout: u32, sequence: Option<u32>) -> Self {
-        Self {
-            txid,
-            vout,
-            sequence,
-        }
-    }
-
-    #[cfg(feature = "test-blockchains")]
-    pub fn into_raw_tx_input(self) -> bitcoincore_rpc::json::CreateRawTransactionInput {
-        bitcoincore_rpc::json::CreateRawTransactionInput {
-            txid: self.txid,
-            vout: self.vout,
-            sequence: self.sequence,
-        }
-    }
-}
+use miniscript::descriptor::DescriptorPublicKey;
+use miniscript::{Descriptor, MiniscriptKey, TranslatePk};
 
 #[derive(Clone, Debug)]
 pub struct TestIncomingOutput {
@@ -63,7 +37,6 @@ impl TestIncomingOutput {
 
 #[derive(Clone, Debug)]
 pub struct TestIncomingTx {
-    pub input: Vec<TestIncomingInput>,
     pub output: Vec<TestIncomingOutput>,
     pub min_confirmations: Option<u64>,
     pub locktime: Option<i64>,
@@ -72,14 +45,12 @@ pub struct TestIncomingTx {
 
 impl TestIncomingTx {
     pub fn new(
-        input: Vec<TestIncomingInput>,
         output: Vec<TestIncomingOutput>,
         min_confirmations: Option<u64>,
         locktime: Option<i64>,
         replaceable: Option<bool>,
     ) -> Self {
         Self {
-            input,
             output,
             min_confirmations,
             locktime,
@@ -87,15 +58,44 @@ impl TestIncomingTx {
         }
     }
 
-    pub fn add_input(&mut self, input: TestIncomingInput) {
-        self.input.push(input);
-    }
-
     pub fn add_output(&mut self, output: TestIncomingOutput) {
         self.output.push(output);
     }
 }
 
+#[doc(hidden)]
+pub trait TranslateDescriptor {
+    // derive and translate a `Descriptor<DescriptorPublicKey>` into a `Descriptor<PublicKey>`
+    fn derive_translated<C: Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        index: u32,
+    ) -> Descriptor<PublicKey>;
+}
+
+impl TranslateDescriptor for Descriptor<DescriptorPublicKey> {
+    fn derive_translated<C: Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        index: u32,
+    ) -> Descriptor<PublicKey> {
+        let translate = |key: &DescriptorPublicKey| -> PublicKey {
+            match key {
+                DescriptorPublicKey::XPub(xpub) => {
+                    xpub.xkey
+                        .derive_pub(secp, &xpub.derivation_path)
+                        .expect("hardened derivation steps")
+                        .public_key
+                }
+                DescriptorPublicKey::SinglePub(key) => key.key,
+            }
+        };
+
+        self.derive(index)
+            .translate_pk_infallible(|pk| translate(pk), |pkh| translate(pkh).to_pubkeyhash())
+    }
+}
+
 #[doc(hidden)]
 #[macro_export]
 macro_rules! testutils {
@@ -103,41 +103,36 @@ macro_rules! testutils {
         use $crate::bitcoin::secp256k1::Secp256k1;
         use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 
-        use $crate::descriptor::AsDerived;
+        use $crate::testutils::TranslateDescriptor;
 
         let secp = Secp256k1::new();
 
         let parsed = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &$descriptors.0).expect("Failed to parse descriptor in `testutils!(@external)`").0;
-        parsed.as_derived($child, &secp).address(bitcoin::Network::Regtest).expect("No address form")
+        parsed.derive_translated(&secp, $child).address(bitcoin::Network::Regtest).expect("No address form")
     });
     ( @internal $descriptors:expr, $child:expr ) => ({
         use $crate::bitcoin::secp256k1::Secp256k1;
         use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 
-        use $crate::descriptor::AsDerived;
+        use $crate::testutils::TranslateDescriptor;
 
         let secp = Secp256k1::new();
 
         let parsed = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &$descriptors.1.expect("Missing internal descriptor")).expect("Failed to parse descriptor in `testutils!(@internal)`").0;
-        parsed.as_derived($child, &secp).address($crate::bitcoin::Network::Regtest).expect("No address form")
+        parsed.derive_translated(&secp, $child).address($crate::bitcoin::Network::Regtest).expect("No address form")
     });
     ( @e $descriptors:expr, $child:expr ) => ({ testutils!(@external $descriptors, $child) });
     ( @i $descriptors:expr, $child:expr ) => ({ testutils!(@internal $descriptors, $child) });
-    ( @addr $addr:expr ) => ({ $addr });
 
-    ( @tx ( $( ( $( $addr:tt )* ) => $amount:expr ),+ ) $( ( @inputs $( ($txid:expr, $vout:expr) ),+ ) )? $( ( @locktime $locktime:expr ) )? $( ( @confirmations $confirmations:expr ) )? $( ( @replaceable $replaceable:expr ) )? ) => ({
+    ( @tx ( $( ( $( $addr:tt )* ) => $amount:expr ),+ ) $( ( @locktime $locktime:expr ) )? $( ( @confirmations $confirmations:expr ) )? $( ( @replaceable $replaceable:expr ) )? ) => ({
         let outs = vec![$( $crate::testutils::TestIncomingOutput::new($amount, testutils!( $($addr)* ))),+];
-        let _ins: Vec<$crate::testutils::TestIncomingInput> = vec![];
-        $(
-            let _ins = vec![$( $crate::testutils::TestIncomingInput { txid: $txid, vout: $vout, sequence: None }),+];
-        )?
 
         let locktime = None::<i64>$(.or(Some($locktime)))?;
 
         let min_confirmations = None::<u64>$(.or(Some($confirmations)))?;
         let replaceable = None::<bool>$(.or(Some($replaceable)))?;
 
-        $crate::testutils::TestIncomingTx::new(_ins, outs, min_confirmations, locktime, replaceable)
+        $crate::testutils::TestIncomingTx::new(outs, min_confirmations, locktime, replaceable)
     });
 
     ( @literal $key:expr ) => ({

src/types.rs

@@ -131,8 +131,6 @@ pub struct LocalUtxo {
     pub txout: TxOut,
     /// Type of keychain
     pub keychain: KeychainKind,
-    /// Whether this UTXO is spent or not
-    pub is_spent: bool,
 }
 
 /// A [`Utxo`] with its `satisfaction_weight`.
@@ -202,10 +200,8 @@ pub struct TransactionDetails {
     pub txid: Txid,
 
     /// Received value (sats)
-    /// Sum of owned outputs of this transaction.
     pub received: u64,
     /// Sent value (sats)
-    /// Sum of owned inputs of this transaction.
     pub sent: u64,
     /// Fee value (sats) if available.
     /// The availability of the fee depends on the backend. It's never `None` with an Electrum
@@ -215,6 +211,15 @@ pub struct TransactionDetails {
     /// If the transaction is confirmed, contains height and timestamp of the block containing the
     /// transaction, unconfirmed transaction contains `None`.
     pub confirmation_time: Option<BlockTime>,
+    /// Whether the tx has been verified against the consensus rules
+    ///
+    /// Confirmed txs are considered "verified" by default, while unconfirmed txs are checked to
+    /// ensure an unstrusted [`Blockchain`](crate::blockchain::Blockchain) backend can't trick the
+    /// wallet into using an invalid tx as an RBF template.
+    ///
+    /// The check is only performed when the `verify` feature is enabled.
+    #[serde(default = "bool::default")] // default to `false` if not specified
+    pub verified: bool,
 }
 
 /// Block height and timestamp of a block

src/wallet/address_validator.rs

@@ -100,7 +100,6 @@ impl std::error::Error for AddressValidatorError {}
 /// validator will be propagated up to the original caller that triggered the address generation.
 ///
 /// For a usage example see [this module](crate::address_validator)'s documentation.
-#[deprecated = "AddressValidator was rarely used. Address validation can occur outside of BDK"]
 pub trait AddressValidator: Send + Sync + fmt::Debug {
     /// Validate or inspect an address
     fn validate(
@@ -121,7 +120,6 @@ mod test {
 
     #[derive(Debug)]
     struct TestValidator;
-    #[allow(deprecated)]
     impl AddressValidator for TestValidator {
         fn validate(
             &self,
@@ -137,7 +135,6 @@ mod test {
     #[should_panic(expected = "InvalidScript")]
     fn test_address_validator_external() {
         let (mut wallet, _, _) = get_funded_wallet(get_test_wpkh());
-        #[allow(deprecated)]
         wallet.add_address_validator(Arc::new(TestValidator));
 
         wallet.get_address(New).unwrap();
@@ -147,7 +144,6 @@ mod test {
     #[should_panic(expected = "InvalidScript")]
     fn test_address_validator_internal() {
         let (mut wallet, descriptors, _) = get_funded_wallet(get_test_wpkh());
-        #[allow(deprecated)]
         wallet.add_address_validator(Arc::new(TestValidator));
 
         let addr = crate::testutils!(@external descriptors, 10);

src/wallet/coin_selection.rs

@@ -97,7 +97,6 @@ use rand::seq::SliceRandom;
 use rand::thread_rng;
 #[cfg(test)]
 use rand::{rngs::StdRng, SeedableRng};
-use std::collections::HashMap;
 use std::convert::TryInto;
 
 /// Default coin selection algorithm used by [`TxBuilder`](super::tx_builder::TxBuilder) if not
@@ -183,7 +182,7 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
         mut optional_utxos: Vec<WeightedUtxo>,
         fee_rate: FeeRate,
         amount_needed: u64,
-        fee_amount: u64,
+        mut fee_amount: u64,
     ) -> Result<CoinSelectionResult, Error> {
         log::debug!(
             "amount_needed = `{}`, fee_amount = `{}`, fee_rate = `{:?}`",
@@ -202,113 +201,47 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
                 .chain(optional_utxos.into_iter().rev().map(|utxo| (false, utxo)))
         };
 
-        select_sorted_utxos(utxos, fee_rate, amount_needed, fee_amount)
-    }
-}
+        // Keep including inputs until we've got enough.
+        // Store the total input value in selected_amount and the total fee being paid in fee_amount
+        let mut selected_amount = 0;
+        let selected = utxos
+            .scan(
+                (&mut selected_amount, &mut fee_amount),
+                |(selected_amount, fee_amount), (must_use, weighted_utxo)| {
+                    if must_use || **selected_amount < amount_needed + **fee_amount {
+                        **fee_amount +=
+                            fee_rate.fee_wu(TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight);
+                        **selected_amount += weighted_utxo.utxo.txout().value;
 
-/// OldestFirstCoinSelection always picks the utxo with the smallest blockheight to add to the selected coins next
-///
-/// This coin selection algorithm sorts the available UTXOs by blockheight and then picks them starting
-/// from the oldest ones until the required amount is reached.
-#[derive(Debug, Default, Clone, Copy)]
-pub struct OldestFirstCoinSelection;
+                        log::debug!(
+                            "Selected {}, updated fee_amount = `{}`",
+                            weighted_utxo.utxo.outpoint(),
+                            fee_amount
+                        );
 
-impl<D: Database> CoinSelectionAlgorithm<D> for OldestFirstCoinSelection {
-    fn coin_select(
-        &self,
-        database: &D,
-        required_utxos: Vec<WeightedUtxo>,
-        mut optional_utxos: Vec<WeightedUtxo>,
-        fee_rate: FeeRate,
-        amount_needed: u64,
-        fee_amount: u64,
-    ) -> Result<CoinSelectionResult, Error> {
-        // query db and create a blockheight lookup table
-        let blockheights = optional_utxos
-            .iter()
-            .map(|wu| wu.utxo.outpoint().txid)
-            // fold is used so we can skip db query for txid that already exist in hashmap acc
-            .fold(Ok(HashMap::new()), |bh_result_acc, txid| {
-                bh_result_acc.and_then(|mut bh_acc| {
-                    if bh_acc.contains_key(&txid) {
-                        Ok(bh_acc)
+                        Some(weighted_utxo.utxo)
                     } else {
-                        database.get_tx(&txid, false).map(|details| {
-                            bh_acc.insert(
-                                txid,
-                                details.and_then(|d| d.confirmation_time.map(|ct| ct.height)),
-                            );
-                            bh_acc
-                        })
+                        None
                     }
-                })
-            })?;
+                },
+            )
+            .collect::<Vec<_>>();
 
-        // We put the "required UTXOs" first and make sure the optional UTXOs are sorted from
-        // oldest to newest according to blocktime
-        // For utxo that doesn't exist in DB, they will have lowest priority to be selected
-        let utxos = {
-            optional_utxos.sort_unstable_by_key(|wu| {
-                match blockheights.get(&wu.utxo.outpoint().txid) {
-                    Some(Some(blockheight)) => blockheight,
-                    _ => &u32::MAX,
-                }
+        let amount_needed_with_fees = amount_needed + fee_amount;
+        if selected_amount < amount_needed_with_fees {
+            return Err(Error::InsufficientFunds {
+                needed: amount_needed_with_fees,
+                available: selected_amount,
             });
+        }
 
-            required_utxos
-                .into_iter()
-                .map(|utxo| (true, utxo))
-                .chain(optional_utxos.into_iter().map(|utxo| (false, utxo)))
-        };
-
-        select_sorted_utxos(utxos, fee_rate, amount_needed, fee_amount)
+        Ok(CoinSelectionResult {
+            selected,
+            fee_amount,
+        })
     }
 }
 
-fn select_sorted_utxos(
-    utxos: impl Iterator<Item = (bool, WeightedUtxo)>,
-    fee_rate: FeeRate,
-    amount_needed: u64,
-    mut fee_amount: u64,
-) -> Result<CoinSelectionResult, Error> {
-    let mut selected_amount = 0;
-    let selected = utxos
-        .scan(
-            (&mut selected_amount, &mut fee_amount),
-            |(selected_amount, fee_amount), (must_use, weighted_utxo)| {
-                if must_use || **selected_amount < amount_needed + **fee_amount {
-                    **fee_amount +=
-                        fee_rate.fee_wu(TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight);
-                    **selected_amount += weighted_utxo.utxo.txout().value;
-
-                    log::debug!(
-                        "Selected {}, updated fee_amount = `{}`",
-                        weighted_utxo.utxo.outpoint(),
-                        fee_amount
-                    );
-
-                    Some(weighted_utxo.utxo)
-                } else {
-                    None
-                }
-            },
-        )
-        .collect::<Vec<_>>();
-
-    let amount_needed_with_fees = amount_needed + fee_amount;
-    if selected_amount < amount_needed_with_fees {
-        return Err(Error::InsufficientFunds {
-            needed: amount_needed_with_fees,
-            available: selected_amount,
-        });
-    }
-
-    Ok(CoinSelectionResult {
-        selected,
-        fee_amount,
-    })
-}
-
 #[derive(Debug, Clone)]
 // Adds fee information to an UTXO.
 struct OutputGroup {
@@ -608,7 +541,7 @@ mod test {
     use bitcoin::{OutPoint, Script, TxOut};
 
     use super::*;
-    use crate::database::{BatchOperations, MemoryDatabase};
+    use crate::database::MemoryDatabase;
     use crate::types::*;
     use crate::wallet::Vbytes;
 
@@ -636,7 +569,6 @@ mod test {
                     script_pubkey: Script::new(),
                 },
                 keychain: KeychainKind::External,
-                is_spent: false,
             }),
         }
     }
@@ -649,61 +581,6 @@ mod test {
         ]
     }
 
-    fn setup_database_and_get_oldest_first_test_utxos<D: Database>(
-        database: &mut D,
-    ) -> Vec<WeightedUtxo> {
-        // ensure utxos are from different tx
-        let utxo1 = utxo(120_000, 1);
-        let utxo2 = utxo(80_000, 2);
-        let utxo3 = utxo(300_000, 3);
-
-        // add tx to DB so utxos are sorted by blocktime asc
-        // utxos will be selected by the following order
-        // utxo1(blockheight 1) -> utxo2(blockheight 2), utxo3 (blockheight 3)
-        // timestamp are all set as the same to ensure that only block height is used in sorting
-        let utxo1_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo1.utxo.outpoint().txid,
-            received: 1,
-            sent: 0,
-            fee: None,
-            confirmation_time: Some(BlockTime {
-                height: 1,
-                timestamp: 1231006505,
-            }),
-        };
-
-        let utxo2_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo2.utxo.outpoint().txid,
-            received: 1,
-            sent: 0,
-            fee: None,
-            confirmation_time: Some(BlockTime {
-                height: 2,
-                timestamp: 1231006505,
-            }),
-        };
-
-        let utxo3_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo3.utxo.outpoint().txid,
-            received: 1,
-            sent: 0,
-            fee: None,
-            confirmation_time: Some(BlockTime {
-                height: 3,
-                timestamp: 1231006505,
-            }),
-        };
-
-        database.set_tx(&utxo1_tx_details).unwrap();
-        database.set_tx(&utxo2_tx_details).unwrap();
-        database.set_tx(&utxo3_tx_details).unwrap();
-
-        vec![utxo1, utxo2, utxo3]
-    }
-
     fn generate_random_utxos(rng: &mut StdRng, utxos_number: usize) -> Vec<WeightedUtxo> {
         let mut res = Vec::new();
         for _ in 0..utxos_number {
@@ -719,7 +596,6 @@ mod test {
                         script_pubkey: Script::new(),
                     },
                     keychain: KeychainKind::External,
-                    is_spent: false,
                 }),
             });
         }
@@ -739,7 +615,6 @@ mod test {
                     script_pubkey: Script::new(),
                 },
                 keychain: KeychainKind::External,
-                is_spent: false,
             }),
         };
         vec![utxo; utxos_number]
@@ -853,164 +728,6 @@ mod test {
             .unwrap();
     }
 
-    #[test]
-    fn test_oldest_first_coin_selection_success() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
-
-        let result = OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                utxos,
-                FeeRate::from_sat_per_vb(1.0),
-                180_000,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-
-        assert_eq!(result.selected.len(), 2);
-        assert_eq!(result.selected_amount(), 200_000);
-        assert_eq!(result.fee_amount, 186)
-    }
-
-    #[test]
-    fn test_oldest_first_coin_selection_utxo_not_in_db_will_be_selected_last() {
-        // ensure utxos are from different tx
-        let utxo1 = utxo(120_000, 1);
-        let utxo2 = utxo(80_000, 2);
-        let utxo3 = utxo(300_000, 3);
-
-        let mut database = MemoryDatabase::default();
-
-        // add tx to DB so utxos are sorted by blocktime asc
-        // utxos will be selected by the following order
-        // utxo1(blockheight 1) -> utxo2(blockheight 2), utxo3 (not exist in DB)
-        // timestamp are all set as the same to ensure that only block height is used in sorting
-        let utxo1_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo1.utxo.outpoint().txid,
-            received: 1,
-            sent: 0,
-            fee: None,
-            confirmation_time: Some(BlockTime {
-                height: 1,
-                timestamp: 1231006505,
-            }),
-        };
-
-        let utxo2_tx_details = TransactionDetails {
-            transaction: None,
-            txid: utxo2.utxo.outpoint().txid,
-            received: 1,
-            sent: 0,
-            fee: None,
-            confirmation_time: Some(BlockTime {
-                height: 2,
-                timestamp: 1231006505,
-            }),
-        };
-
-        database.set_tx(&utxo1_tx_details).unwrap();
-        database.set_tx(&utxo2_tx_details).unwrap();
-
-        let result = OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                vec![utxo3, utxo1, utxo2],
-                FeeRate::from_sat_per_vb(1.0),
-                180_000,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-
-        assert_eq!(result.selected.len(), 2);
-        assert_eq!(result.selected_amount(), 200_000);
-        assert_eq!(result.fee_amount, 186)
-    }
-
-    #[test]
-    fn test_oldest_first_coin_selection_use_all() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
-
-        let result = OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                utxos,
-                vec![],
-                FeeRate::from_sat_per_vb(1.0),
-                20_000,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-
-        assert_eq!(result.selected.len(), 3);
-        assert_eq!(result.selected_amount(), 500_000);
-        assert_eq!(result.fee_amount, 254);
-    }
-
-    #[test]
-    fn test_oldest_first_coin_selection_use_only_necessary() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
-
-        let result = OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                utxos,
-                FeeRate::from_sat_per_vb(1.0),
-                20_000,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-
-        assert_eq!(result.selected.len(), 1);
-        assert_eq!(result.selected_amount(), 120_000);
-        assert_eq!(result.fee_amount, 118);
-    }
-
-    #[test]
-    #[should_panic(expected = "InsufficientFunds")]
-    fn test_oldest_first_coin_selection_insufficient_funds() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
-
-        OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                utxos,
-                FeeRate::from_sat_per_vb(1.0),
-                600_000,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "InsufficientFunds")]
-    fn test_oldest_first_coin_selection_insufficient_funds_high_fees() {
-        let mut database = MemoryDatabase::default();
-        let utxos = setup_database_and_get_oldest_first_test_utxos(&mut database);
-
-        let amount_needed: u64 =
-            utxos.iter().map(|wu| wu.utxo.txout().value).sum::<u64>() - (FEE_AMOUNT + 50);
-
-        OldestFirstCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                utxos,
-                FeeRate::from_sat_per_vb(1000.0),
-                amount_needed,
-                FEE_AMOUNT,
-            )
-            .unwrap();
-    }
-
     #[test]
     fn test_bnb_coin_selection_success() {
         // In this case bnb won't find a suitable match and single random draw will

src/wallet/export.rs

@@ -29,7 +29,7 @@
 //!     "label":"testnet"
 //! }"#;
 //!
-//! let import = FullyNodedExport::from_str(import)?;
+//! let import = WalletExport::from_str(import)?;
 //! let wallet = Wallet::new(
 //!     &import.descriptor(),
 //!     import.change_descriptor().as_ref(),
@@ -51,7 +51,7 @@
 //!     Network::Testnet,
 //!     MemoryDatabase::default()
 //! )?;
-//! let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+//! let export = WalletExport::export_wallet(&wallet, "exported wallet", true)
 //!     .map_err(ToString::to_string)
 //!     .map_err(bdk::Error::Generic)?;
 //!
@@ -64,21 +64,16 @@ use std::str::FromStr;
 use serde::{Deserialize, Serialize};
 
 use miniscript::descriptor::{ShInner, WshInner};
-use miniscript::{Descriptor, ScriptContext, Terminal};
+use miniscript::{Descriptor, DescriptorPublicKey, ScriptContext, Terminal};
 
 use crate::database::BatchDatabase;
-use crate::types::KeychainKind;
 use crate::wallet::Wallet;
 
-/// Alias for [`FullyNodedExport`]
-#[deprecated(since = "0.18.0", note = "Please use [`FullyNodedExport`] instead")]
-pub type WalletExport = FullyNodedExport;
-
 /// Structure that contains the export of a wallet
 ///
 /// For a usage example see [this module](crate::wallet::export)'s documentation.
 #[derive(Debug, Serialize, Deserialize)]
-pub struct FullyNodedExport {
+pub struct WalletExport {
     descriptor: String,
     /// Earliest block to rescan when looking for the wallet's transactions
     pub blockheight: u32,
@@ -86,13 +81,13 @@ pub struct FullyNodedExport {
     pub label: String,
 }
 
-impl ToString for FullyNodedExport {
+impl ToString for WalletExport {
     fn to_string(&self) -> String {
         serde_json::to_string(self).unwrap()
     }
 }
 
-impl FromStr for FullyNodedExport {
+impl FromStr for WalletExport {
     type Err = serde_json::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -101,10 +96,10 @@ impl FromStr for FullyNodedExport {
 }
 
 fn remove_checksum(s: String) -> String {
-    s.split_once('#').map(|(a, _)| String::from(a)).unwrap()
+    s.splitn(2, '#').next().map(String::from).unwrap()
 }
 
-impl FullyNodedExport {
+impl WalletExport {
     /// Export a wallet
     ///
     /// This function returns an error if it determines that the `wallet`'s descriptor(s) are not
@@ -122,12 +117,8 @@ impl FullyNodedExport {
         include_blockheight: bool,
     ) -> Result<Self, &'static str> {
         let descriptor = wallet
-            .get_descriptor_for_keychain(KeychainKind::External)
-            .to_string_with_secret(
-                &wallet
-                    .get_signers(KeychainKind::External)
-                    .as_key_map(wallet.secp_ctx()),
-            );
+            .descriptor
+            .to_string_with_secret(&wallet.signers.as_key_map(wallet.secp_ctx()));
         let descriptor = remove_checksum(descriptor);
         Self::is_compatible_with_core(&descriptor)?;
 
@@ -145,30 +136,18 @@ impl FullyNodedExport {
             }
         };
 
-        let export = FullyNodedExport {
+        let export = WalletExport {
             descriptor,
             label: label.into(),
             blockheight,
         };
 
-        let change_descriptor = match wallet
-            .public_descriptor(KeychainKind::Internal)
-            .map_err(|_| "Invalid change descriptor")?
-            .is_some()
-        {
-            false => None,
-            true => {
-                let descriptor = wallet
-                    .get_descriptor_for_keychain(KeychainKind::Internal)
-                    .to_string_with_secret(
-                        &wallet
-                            .get_signers(KeychainKind::Internal)
-                            .as_key_map(wallet.secp_ctx()),
-                    );
-                Some(remove_checksum(descriptor))
-            }
+        let desc_to_string = |d: &Descriptor<DescriptorPublicKey>| {
+            let descriptor =
+                d.to_string_with_secret(&wallet.change_signers.as_key_map(wallet.secp_ctx()));
+            remove_checksum(descriptor)
         };
-        if export.change_descriptor() != change_descriptor {
+        if export.change_descriptor() != wallet.change_descriptor.as_ref().map(desc_to_string) {
             return Err("Incompatible change descriptor");
         }
 
@@ -251,6 +230,7 @@ mod test {
                 timestamp: 12345678,
                 height: 5000,
             }),
+            verified: true,
         })
         .unwrap();
 
@@ -269,7 +249,7 @@ mod test {
             get_test_db(),
         )
         .unwrap();
-        let export = FullyNodedExport::export_wallet(&wallet, "Test Label", true).unwrap();
+        let export = WalletExport::export_wallet(&wallet, "Test Label", true).unwrap();
 
         assert_eq!(export.descriptor(), descriptor);
         assert_eq!(export.change_descriptor(), Some(change_descriptor.into()));
@@ -287,7 +267,7 @@ mod test {
         let descriptor = "wpkh(xprv9s21ZrQH143K4CTb63EaMxja1YiTnSEWKMbn23uoEnAzxjdUJRQkazCAtzxGm4LSoTSVTptoV9RbchnKPW9HxKtZumdyxyikZFDLhogJ5Uj/44'/0'/0'/0/*)";
 
         let wallet = Wallet::new(descriptor, None, Network::Bitcoin, get_test_db()).unwrap();
-        FullyNodedExport::export_wallet(&wallet, "Test Label", true).unwrap();
+        WalletExport::export_wallet(&wallet, "Test Label", true).unwrap();
     }
 
     #[test]
@@ -306,7 +286,7 @@ mod test {
             get_test_db(),
         )
         .unwrap();
-        FullyNodedExport::export_wallet(&wallet, "Test Label", true).unwrap();
+        WalletExport::export_wallet(&wallet, "Test Label", true).unwrap();
     }
 
     #[test]
@@ -329,7 +309,7 @@ mod test {
             get_test_db(),
         )
         .unwrap();
-        let export = FullyNodedExport::export_wallet(&wallet, "Test Label", true).unwrap();
+        let export = WalletExport::export_wallet(&wallet, "Test Label", true).unwrap();
 
         assert_eq!(export.descriptor(), descriptor);
         assert_eq!(export.change_descriptor(), Some(change_descriptor.into()));
@@ -349,7 +329,7 @@ mod test {
             get_test_db(),
         )
         .unwrap();
-        let export = FullyNodedExport::export_wallet(&wallet, "Test Label", true).unwrap();
+        let export = WalletExport::export_wallet(&wallet, "Test Label", true).unwrap();
 
         assert_eq!(export.to_string(), "{\"descriptor\":\"wpkh(xprv9s21ZrQH143K4CTb63EaMxja1YiTnSEWKMbn23uoEnAzxjdUJRQkazCAtzxGm4LSoTSVTptoV9RbchnKPW9HxKtZumdyxyikZFDLhogJ5Uj/44\'/0\'/0\'/0/*)\",\"blockheight\":5000,\"label\":\"Test Label\"}");
     }
@@ -360,7 +340,7 @@ mod test {
         let change_descriptor = "wpkh(xprv9s21ZrQH143K4CTb63EaMxja1YiTnSEWKMbn23uoEnAzxjdUJRQkazCAtzxGm4LSoTSVTptoV9RbchnKPW9HxKtZumdyxyikZFDLhogJ5Uj/44'/0'/0'/1/*)";
 
         let import_str = "{\"descriptor\":\"wpkh(xprv9s21ZrQH143K4CTb63EaMxja1YiTnSEWKMbn23uoEnAzxjdUJRQkazCAtzxGm4LSoTSVTptoV9RbchnKPW9HxKtZumdyxyikZFDLhogJ5Uj/44\'/0\'/0\'/0/*)\",\"blockheight\":5000,\"label\":\"Test Label\"}";
-        let export = FullyNodedExport::from_str(import_str).unwrap();
+        let export = WalletExport::from_str(import_str).unwrap();
 
         assert_eq!(export.descriptor(), descriptor);
         assert_eq!(export.change_descriptor(), Some(change_descriptor.into()));

src/wallet/signer.rs

@@ -26,7 +26,7 @@
 //! # #[derive(Debug)]
 //! # struct CustomHSM;
 //! # impl CustomHSM {
-//! #     fn hsm_sign_input(&self, _psbt: &mut psbt::PartiallySignedTransaction, _input: usize) -> Result<(), SignerError> {
+//! #     fn sign_input(&self, _psbt: &mut psbt::PartiallySignedTransaction, _input: usize) -> Result<(), SignerError> {
 //! #         Ok(())
 //! #     }
 //! #     fn connect() -> Self {
@@ -47,22 +47,25 @@
 //!     }
 //! }
 //!
-//! impl SignerCommon for CustomSigner {
+//! impl Signer for CustomSigner {
+//!     fn sign(
+//!         &self,
+//!         psbt: &mut psbt::PartiallySignedTransaction,
+//!         input_index: Option<usize>,
+//!         _secp: &Secp256k1<All>,
+//!     ) -> Result<(), SignerError> {
+//!         let input_index = input_index.ok_or(SignerError::InputIndexOutOfRange)?;
+//!         self.device.sign_input(psbt, input_index)?;
+//!
+//!         Ok(())
+//!     }
+//!
 //!     fn id(&self, _secp: &Secp256k1<All>) -> SignerId {
 //!         self.device.get_id()
 //!     }
-//! }
 //!
-//! impl InputSigner for CustomSigner {
-//!     fn sign_input(
-//!         &self,
-//!         psbt: &mut psbt::PartiallySignedTransaction,
-//!         input_index: usize,
-//!         _secp: &Secp256k1<All>,
-//!     ) -> Result<(), SignerError> {
-//!         self.device.hsm_sign_input(psbt, input_index)?;
-//!
-//!         Ok(())
+//!     fn sign_whole_tx(&self) -> bool {
+//!         false
 //!     }
 //! }
 //!
@@ -82,26 +85,22 @@
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::fmt;
-use std::ops::{Bound::Included, Deref};
+use std::ops::Bound::Included;
 use std::sync::Arc;
 
 use bitcoin::blockdata::opcodes;
 use bitcoin::blockdata::script::Builder as ScriptBuilder;
 use bitcoin::hashes::{hash160, Hash};
-use bitcoin::secp256k1::Message;
+use bitcoin::secp256k1::{Message, Secp256k1};
 use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, Fingerprint};
-use bitcoin::util::{ecdsa, psbt, schnorr, sighash, taproot};
-use bitcoin::{secp256k1, XOnlyPublicKey};
-use bitcoin::{EcdsaSighashType, PrivateKey, PublicKey, SchnorrSighashType, Script};
+use bitcoin::util::{bip143, psbt};
+use bitcoin::{PrivateKey, Script, SigHash, SigHashType};
 
-use miniscript::descriptor::{
-    Descriptor, DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePriv, DescriptorXKey,
-    KeyMap, SinglePubKey,
-};
-use miniscript::{Legacy, MiniscriptKey, Segwitv0, Tap};
+use miniscript::descriptor::{DescriptorSecretKey, DescriptorSinglePriv, DescriptorXKey, KeyMap};
+use miniscript::{Legacy, MiniscriptKey, Segwitv0};
 
 use super::utils::SecpCtx;
-use crate::descriptor::{DescriptorMeta, XKeyUtils};
+use crate::descriptor::XKeyUtils;
 
 /// Identifier of a signer in the `SignersContainers`. Used as a key to find the right signer among
 /// multiple of them
@@ -154,16 +153,6 @@ pub enum SignerError {
     /// To enable signing transactions with non-standard sighashes set
     /// [`SignOptions::allow_all_sighashes`] to `true`.
     NonStandardSighash,
-    /// Invalid SIGHASH for the signing context in use
-    InvalidSighash,
-    /// Error while computing the hash to sign
-    SighashError(sighash::Error),
-}
-
-impl From<sighash::Error> for SignerError {
-    fn from(e: sighash::Error) -> Self {
-        SignerError::SighashError(e)
-    }
 }
 
 impl fmt::Display for SignerError {
@@ -174,46 +163,27 @@ impl fmt::Display for SignerError {
 
 impl std::error::Error for SignerError {}
 
-/// Signing context
+/// Trait for signers
 ///
-/// Used by our software signers to determine the type of signatures to make
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SignerContext {
-    /// Legacy context
-    Legacy,
-    /// Segwit v0 context (BIP 143)
-    Segwitv0,
-    /// Taproot context (BIP 340)
-    Tap {
-        /// Whether the signer can sign for the internal key or not
-        is_internal_key: bool,
-    },
-}
+/// This trait can be implemented to provide customized signers to the wallet. For an example see
+/// [`this module`](crate::wallet::signer)'s documentation.
+pub trait Signer: fmt::Debug + Send + Sync {
+    /// Sign a PSBT
+    ///
+    /// The `input_index` argument is only provided if the wallet doesn't declare to sign the whole
+    /// transaction in one go (see [`Signer::sign_whole_tx`]). Otherwise its value is `None` and
+    /// can be ignored.
+    fn sign(
+        &self,
+        psbt: &mut psbt::PartiallySignedTransaction,
+        input_index: Option<usize>,
+        secp: &SecpCtx,
+    ) -> Result<(), SignerError>;
 
-/// Wrapper structure to pair a signer with its context
-#[derive(Debug, Clone)]
-pub struct SignerWrapper<S: Sized + fmt::Debug + Clone> {
-    signer: S,
-    ctx: SignerContext,
-}
+    /// Return whether or not the signer signs the whole transaction in one go instead of every
+    /// input individually
+    fn sign_whole_tx(&self) -> bool;
 
-impl<S: Sized + fmt::Debug + Clone> SignerWrapper<S> {
-    /// Create a wrapped signer from a signer and a context
-    pub fn new(signer: S, ctx: SignerContext) -> Self {
-        SignerWrapper { signer, ctx }
-    }
-}
-
-impl<S: Sized + fmt::Debug + Clone> Deref for SignerWrapper<S> {
-    type Target = S;
-
-    fn deref(&self) -> &Self::Target {
-        &self.signer
-    }
-}
-
-/// Common signer methods
-pub trait SignerCommon: fmt::Debug + Send + Sync {
     /// Return the [`SignerId`] for this signer
     ///
     /// The [`SignerId`] can be used to lookup a signer in the [`Wallet`](crate::Wallet)'s signers map or to
@@ -230,65 +200,14 @@ pub trait SignerCommon: fmt::Debug + Send + Sync {
     }
 }
 
-/// PSBT Input signer
-///
-/// This trait can be implemented to provide custom signers to the wallet. If the signer supports signing
-/// individual inputs, this trait should be implemented and BDK will provide automatically an implementation
-/// for [`TransactionSigner`].
-pub trait InputSigner: SignerCommon {
-    /// Sign a single psbt input
-    fn sign_input(
-        &self,
-        psbt: &mut psbt::PartiallySignedTransaction,
-        input_index: usize,
-        secp: &SecpCtx,
-    ) -> Result<(), SignerError>;
-}
-
-/// PSBT signer
-///
-/// This trait can be implemented when the signer can't sign inputs individually, but signs the whole transaction
-/// at once.
-pub trait TransactionSigner: SignerCommon {
-    /// Sign all the inputs of the psbt
-    fn sign_transaction(
-        &self,
-        psbt: &mut psbt::PartiallySignedTransaction,
-        secp: &SecpCtx,
-    ) -> Result<(), SignerError>;
-}
-
-impl<T: InputSigner> TransactionSigner for T {
-    fn sign_transaction(
+impl Signer for DescriptorXKey<ExtendedPrivKey> {
+    fn sign(
         &self,
         psbt: &mut psbt::PartiallySignedTransaction,
+        input_index: Option<usize>,
         secp: &SecpCtx,
     ) -> Result<(), SignerError> {
-        for input_index in 0..psbt.inputs.len() {
-            self.sign_input(psbt, input_index, secp)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl SignerCommon for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
-    fn id(&self, secp: &SecpCtx) -> SignerId {
-        SignerId::from(self.root_fingerprint(secp))
-    }
-
-    fn descriptor_secret_key(&self) -> Option<DescriptorSecretKey> {
-        Some(DescriptorSecretKey::XPrv(self.signer.clone()))
-    }
-}
-
-impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
-    fn sign_input(
-        &self,
-        psbt: &mut psbt::PartiallySignedTransaction,
-        input_index: usize,
-        secp: &SecpCtx,
-    ) -> Result<(), SignerError> {
+        let input_index = input_index.unwrap();
         if input_index >= psbt.inputs.len() {
             return Err(SignerError::InputIndexOutOfRange);
         }
@@ -299,23 +218,19 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
             return Ok(());
         }
 
-        let tap_key_origins = psbt.inputs[input_index]
-            .tap_key_origins
-            .iter()
-            .map(|(pk, (_, keysource))| (SinglePubKey::XOnly(*pk), keysource));
         let (public_key, full_path) = match psbt.inputs[input_index]
             .bip32_derivation
             .iter()
-            .map(|(pk, keysource)| (SinglePubKey::FullKey(PublicKey::new(*pk)), keysource))
-            .chain(tap_key_origins)
-            .find_map(|(pk, keysource)| {
-                if self.matches(keysource, secp).is_some() {
-                    Some((pk, keysource.1.clone()))
+            .filter_map(|(pk, &(fingerprint, ref path))| {
+                if self.matches(&(fingerprint, path.clone()), secp).is_some() {
+                    Some((pk, path))
                 } else {
                     None
                 }
-            }) {
-            Some((pk, full_path)) => (pk, full_path),
+            })
+            .next()
+        {
+            Some((pk, full_path)) => (pk, full_path.clone()),
             None => return Ok(()),
         };
 
@@ -330,48 +245,35 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
             None => self.xkey.derive_priv(secp, &full_path).unwrap(),
         };
 
-        let computed_pk = secp256k1::PublicKey::from_secret_key(secp, &derived_key.private_key);
-        let valid_key = match public_key {
-            SinglePubKey::FullKey(pk) if pk.inner == computed_pk => true,
-            SinglePubKey::XOnly(x_only) if XOnlyPublicKey::from(computed_pk) == x_only => true,
-            _ => false,
-        };
-        if !valid_key {
+        if &derived_key.private_key.public_key(secp) != public_key {
             Err(SignerError::InvalidKey)
         } else {
-            // HD wallets imply compressed keys
-            let priv_key = PrivateKey {
-                compressed: true,
-                network: self.xkey.network,
-                inner: derived_key.private_key,
-            };
-
-            SignerWrapper::new(priv_key, self.ctx).sign_input(psbt, input_index, secp)
+            derived_key.private_key.sign(psbt, Some(input_index), secp)
         }
     }
-}
 
-impl SignerCommon for SignerWrapper<PrivateKey> {
+    fn sign_whole_tx(&self) -> bool {
+        false
+    }
+
     fn id(&self, secp: &SecpCtx) -> SignerId {
-        SignerId::from(self.public_key(secp).to_pubkeyhash())
+        SignerId::from(self.root_fingerprint(secp))
     }
 
     fn descriptor_secret_key(&self) -> Option<DescriptorSecretKey> {
-        Some(DescriptorSecretKey::SinglePriv(DescriptorSinglePriv {
-            key: self.signer,
-            origin: None,
-        }))
+        Some(DescriptorSecretKey::XPrv(self.clone()))
     }
 }
 
-impl InputSigner for SignerWrapper<PrivateKey> {
-    fn sign_input(
+impl Signer for PrivateKey {
+    fn sign(
         &self,
         psbt: &mut psbt::PartiallySignedTransaction,
-        input_index: usize,
+        input_index: Option<usize>,
         secp: &SecpCtx,
     ) -> Result<(), SignerError> {
-        if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+        let input_index = input_index.unwrap();
+        if input_index >= psbt.inputs.len() || input_index >= psbt.global.unsigned_tx.input.len() {
             return Err(SignerError::InputIndexOutOfRange);
         }
 
@@ -381,124 +283,49 @@ impl InputSigner for SignerWrapper<PrivateKey> {
             return Ok(());
         }
 
-        let pubkey = PublicKey::from_private_key(secp, self);
-        let x_only_pubkey = XOnlyPublicKey::from(pubkey.inner);
-
-        if let SignerContext::Tap { is_internal_key } = self.ctx {
-            if is_internal_key && psbt.inputs[input_index].tap_key_sig.is_none() {
-                let (hash, hash_ty) = Tap::sighash(psbt, input_index, None)?;
-                sign_psbt_schnorr(
-                    &self.inner,
-                    x_only_pubkey,
-                    None,
-                    &mut psbt.inputs[input_index],
-                    hash,
-                    hash_ty,
-                    secp,
-                );
-            }
-
-            if let Some((leaf_hashes, _)) =
-                psbt.inputs[input_index].tap_key_origins.get(&x_only_pubkey)
-            {
-                let leaf_hashes = leaf_hashes
-                    .iter()
-                    .filter(|lh| {
-                        !psbt.inputs[input_index]
-                            .tap_script_sigs
-                            .contains_key(&(x_only_pubkey, **lh))
-                    })
-                    .cloned()
-                    .collect::<Vec<_>>();
-                for lh in leaf_hashes {
-                    let (hash, hash_ty) = Tap::sighash(psbt, input_index, Some(lh))?;
-                    sign_psbt_schnorr(
-                        &self.inner,
-                        x_only_pubkey,
-                        Some(lh),
-                        &mut psbt.inputs[input_index],
-                        hash,
-                        hash_ty,
-                        secp,
-                    );
-                }
-            }
-
-            return Ok(());
-        }
-
+        let pubkey = self.public_key(secp);
         if psbt.inputs[input_index].partial_sigs.contains_key(&pubkey) {
             return Ok(());
         }
 
-        let (hash, hash_ty) = match self.ctx {
-            SignerContext::Segwitv0 => Segwitv0::sighash(psbt, input_index, ())?,
-            SignerContext::Legacy => Legacy::sighash(psbt, input_index, ())?,
-            _ => return Ok(()), // handled above
+        // FIXME: use the presence of `witness_utxo` as an indication that we should make a bip143
+        // sig. Does this make sense? Should we add an extra argument to explicitly switch between
+        // these? The original idea was to declare sign() as sign<Ctx: ScriptContex>() and use Ctx,
+        // but that violates the rules for trait-objects, so we can't do it.
+        let (hash, sighash) = match psbt.inputs[input_index].witness_utxo {
+            Some(_) => Segwitv0::sighash(psbt, input_index)?,
+            None => Legacy::sighash(psbt, input_index)?,
         };
-        sign_psbt_ecdsa(
-            &self.inner,
-            pubkey,
-            &mut psbt.inputs[input_index],
-            hash,
-            hash_ty,
-            secp,
+
+        let signature = secp.sign(
+            &Message::from_slice(&hash.into_inner()[..]).unwrap(),
+            &self.key,
         );
 
+        let mut final_signature = Vec::with_capacity(75);
+        final_signature.extend_from_slice(&signature.serialize_der());
+        final_signature.push(sighash.as_u32() as u8);
+
+        psbt.inputs[input_index]
+            .partial_sigs
+            .insert(pubkey, final_signature);
+
         Ok(())
     }
-}
 
-fn sign_psbt_ecdsa(
-    secret_key: &secp256k1::SecretKey,
-    pubkey: PublicKey,
-    psbt_input: &mut psbt::Input,
-    hash: bitcoin::Sighash,
-    hash_ty: EcdsaSighashType,
-    secp: &SecpCtx,
-) {
-    let sig = secp.sign_ecdsa(
-        &Message::from_slice(&hash.into_inner()[..]).unwrap(),
-        secret_key,
-    );
+    fn sign_whole_tx(&self) -> bool {
+        false
+    }
 
-    let final_signature = ecdsa::EcdsaSig { sig, hash_ty };
-    psbt_input.partial_sigs.insert(pubkey, final_signature);
-}
+    fn id(&self, secp: &SecpCtx) -> SignerId {
+        SignerId::from(self.public_key(secp).to_pubkeyhash())
+    }
 
-// Calling this with `leaf_hash` = `None` will sign for key-spend
-fn sign_psbt_schnorr(
-    secret_key: &secp256k1::SecretKey,
-    pubkey: XOnlyPublicKey,
-    leaf_hash: Option<taproot::TapLeafHash>,
-    psbt_input: &mut psbt::Input,
-    hash: taproot::TapSighashHash,
-    hash_ty: SchnorrSighashType,
-    secp: &SecpCtx,
-) {
-    use schnorr::TapTweak;
-
-    let keypair = secp256k1::KeyPair::from_seckey_slice(secp, secret_key.as_ref()).unwrap();
-    let keypair = match leaf_hash {
-        None => keypair
-            .tap_tweak(secp, psbt_input.tap_merkle_root)
-            .into_inner(),
-        Some(_) => keypair, // no tweak for script spend
-    };
-
-    let sig = secp.sign_schnorr(
-        &Message::from_slice(&hash.into_inner()[..]).unwrap(),
-        &keypair,
-    );
-
-    let final_signature = schnorr::SchnorrSig { sig, hash_ty };
-
-    if let Some(lh) = leaf_hash {
-        psbt_input
-            .tap_script_sigs
-            .insert((pubkey, lh), final_signature);
-    } else {
-        psbt_input.tap_key_sig = Some(final_signature);
+    fn descriptor_secret_key(&self) -> Option<DescriptorSecretKey> {
+        Some(DescriptorSecretKey::SinglePriv(DescriptorSinglePriv {
+            key: *self,
+            origin: None,
+        }))
     }
 }
 
@@ -533,7 +360,7 @@ impl From<(SignerId, SignerOrdering)> for SignersContainerKey {
 
 /// Container for multiple signers
 #[derive(Debug, Default, Clone)]
-pub struct SignersContainer(BTreeMap<SignersContainerKey, Arc<dyn TransactionSigner>>);
+pub struct SignersContainer(BTreeMap<SignersContainerKey, Arc<dyn Signer>>);
 
 impl SignersContainer {
     /// Create a map of public keys to secret keys
@@ -544,37 +371,24 @@ impl SignersContainer {
             .filter_map(|secret| secret.as_public(secp).ok().map(|public| (public, secret)))
             .collect()
     }
+}
 
-    /// Build a new signer container from a [`KeyMap`]
-    ///
-    /// Also looks at the corresponding descriptor to determine the [`SignerContext`] to attach to
-    /// the signers
-    pub fn build(
-        keymap: KeyMap,
-        descriptor: &Descriptor<DescriptorPublicKey>,
-        secp: &SecpCtx,
-    ) -> SignersContainer {
+impl From<KeyMap> for SignersContainer {
+    fn from(keymap: KeyMap) -> SignersContainer {
+        let secp = Secp256k1::new();
         let mut container = SignersContainer::new();
 
-        for (pubkey, secret) in keymap {
-            let ctx = match descriptor {
-                Descriptor::Tr(tr) => SignerContext::Tap {
-                    is_internal_key: tr.internal_key() == &pubkey,
-                },
-                _ if descriptor.is_witness() => SignerContext::Segwitv0,
-                _ => SignerContext::Legacy,
-            };
-
+        for (_, secret) in keymap {
             match secret {
                 DescriptorSecretKey::SinglePriv(private_key) => container.add_external(
-                    SignerId::from(private_key.key.public_key(secp).to_pubkeyhash()),
+                    SignerId::from(private_key.key.public_key(&secp).to_pubkeyhash()),
                     SignerOrdering::default(),
-                    Arc::new(SignerWrapper::new(private_key.key, ctx)),
+                    Arc::new(private_key.key),
                 ),
                 DescriptorSecretKey::XPrv(xprv) => container.add_external(
-                    SignerId::from(xprv.root_fingerprint(secp)),
+                    SignerId::from(xprv.root_fingerprint(&secp)),
                     SignerOrdering::default(),
-                    Arc::new(SignerWrapper::new(xprv, ctx)),
+                    Arc::new(xprv),
                 ),
             };
         }
@@ -595,17 +409,13 @@ impl SignersContainer {
         &mut self,
         id: SignerId,
         ordering: SignerOrdering,
-        signer: Arc<dyn TransactionSigner>,
-    ) -> Option<Arc<dyn TransactionSigner>> {
+        signer: Arc<dyn Signer>,
+    ) -> Option<Arc<dyn Signer>> {
         self.0.insert((id, ordering).into(), signer)
     }
 
     /// Removes a signer from the container and returns it
-    pub fn remove(
-        &mut self,
-        id: SignerId,
-        ordering: SignerOrdering,
-    ) -> Option<Arc<dyn TransactionSigner>> {
+    pub fn remove(&mut self, id: SignerId, ordering: SignerOrdering) -> Option<Arc<dyn Signer>> {
         self.0.remove(&(id, ordering).into())
     }
 
@@ -618,12 +428,12 @@ impl SignersContainer {
     }
 
     /// Returns the list of signers in the container, sorted by lowest to highest `ordering`
-    pub fn signers(&self) -> Vec<&Arc<dyn TransactionSigner>> {
+    pub fn signers(&self) -> Vec<&Arc<dyn Signer>> {
         self.0.values().collect()
     }
 
     /// Finds the signer with lowest ordering for a given id in the container.
-    pub fn find(&self, id: SignerId) -> Option<&Arc<dyn TransactionSigner>> {
+    pub fn find(&self, id: SignerId) -> Option<&Arc<dyn Signer>> {
         self.0
             .range((
                 Included(&(id.clone(), SignerOrdering(0)).into()),
@@ -667,65 +477,38 @@ pub struct SignOptions {
     ///
     /// Defaults to `false` which will only allow signing using `SIGHASH_ALL`.
     pub allow_all_sighashes: bool,
-
-    /// Whether to remove partial_sigs from psbt inputs while finalizing psbt.
-    ///
-    /// Defaults to `true` which will remove partial_sigs after finalizing.
-    pub remove_partial_sigs: bool,
-
-    /// Whether to try finalizing psbt input after the inputs are signed.
-    ///
-    /// Defaults to `true` which will try fianlizing psbt after inputs are signed.
-    pub try_finalize: bool,
 }
 
-#[allow(clippy::derivable_impls)]
 impl Default for SignOptions {
     fn default() -> Self {
         SignOptions {
             trust_witness_utxo: false,
             assume_height: None,
             allow_all_sighashes: false,
-            remove_partial_sigs: true,
-            try_finalize: true,
         }
     }
 }
 
 pub(crate) trait ComputeSighash {
-    type Extra;
-    type Sighash;
-    type SighashType;
-
     fn sighash(
         psbt: &psbt::PartiallySignedTransaction,
         input_index: usize,
-        extra: Self::Extra,
-    ) -> Result<(Self::Sighash, Self::SighashType), SignerError>;
+    ) -> Result<(SigHash, SigHashType), SignerError>;
 }
 
 impl ComputeSighash for Legacy {
-    type Extra = ();
-    type Sighash = bitcoin::Sighash;
-    type SighashType = EcdsaSighashType;
-
     fn sighash(
         psbt: &psbt::PartiallySignedTransaction,
         input_index: usize,
-        _extra: (),
-    ) -> Result<(Self::Sighash, Self::SighashType), SignerError> {
-        if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+    ) -> Result<(SigHash, SigHashType), SignerError> {
+        if input_index >= psbt.inputs.len() || input_index >= psbt.global.unsigned_tx.input.len() {
             return Err(SignerError::InputIndexOutOfRange);
         }
 
         let psbt_input = &psbt.inputs[input_index];
-        let tx_input = &psbt.unsigned_tx.input[input_index];
+        let tx_input = &psbt.global.unsigned_tx.input[input_index];
 
-        let sighash = psbt_input
-            .sighash_type
-            .unwrap_or_else(|| EcdsaSighashType::All.into())
-            .ecdsa_hash_ty()
-            .map_err(|_| SignerError::InvalidSighash)?;
+        let sighash = psbt_input.sighash_type.unwrap_or(SigHashType::All);
         let script = match psbt_input.redeem_script {
             Some(ref redeem_script) => redeem_script.clone(),
             None => {
@@ -743,11 +526,9 @@ impl ComputeSighash for Legacy {
         };
 
         Ok((
-            sighash::SighashCache::new(&psbt.unsigned_tx).legacy_signature_hash(
-                input_index,
-                &script,
-                sighash.to_u32(),
-            )?,
+            psbt.global
+                .unsigned_tx
+                .signature_hash(input_index, &script, sighash.as_u32()),
             sighash,
         ))
     }
@@ -764,27 +545,18 @@ fn p2wpkh_script_code(script: &Script) -> Script {
 }
 
 impl ComputeSighash for Segwitv0 {
-    type Extra = ();
-    type Sighash = bitcoin::Sighash;
-    type SighashType = EcdsaSighashType;
-
     fn sighash(
         psbt: &psbt::PartiallySignedTransaction,
         input_index: usize,
-        _extra: (),
-    ) -> Result<(Self::Sighash, Self::SighashType), SignerError> {
-        if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+    ) -> Result<(SigHash, SigHashType), SignerError> {
+        if input_index >= psbt.inputs.len() || input_index >= psbt.global.unsigned_tx.input.len() {
             return Err(SignerError::InputIndexOutOfRange);
         }
 
         let psbt_input = &psbt.inputs[input_index];
-        let tx_input = &psbt.unsigned_tx.input[input_index];
+        let tx_input = &psbt.global.unsigned_tx.input[input_index];
 
-        let sighash = psbt_input
-            .sighash_type
-            .unwrap_or_else(|| EcdsaSighashType::All.into())
-            .ecdsa_hash_ty()
-            .map_err(|_| SignerError::InvalidSighash)?;
+        let sighash = psbt_input.sighash_type.unwrap_or(SigHashType::All);
 
         // Always try first with the non-witness utxo
         let utxo = if let Some(prev_tx) = &psbt_input.non_witness_utxo {
@@ -827,72 +599,17 @@ impl ComputeSighash for Segwitv0 {
         };
 
         Ok((
-            sighash::SighashCache::new(&psbt.unsigned_tx).segwit_signature_hash(
+            bip143::SigHashCache::new(&psbt.global.unsigned_tx).signature_hash(
                 input_index,
                 &script,
                 value,
                 sighash,
-            )?,
+            ),
             sighash,
         ))
     }
 }
 
-impl ComputeSighash for Tap {
-    type Extra = Option<taproot::TapLeafHash>;
-    type Sighash = taproot::TapSighashHash;
-    type SighashType = SchnorrSighashType;
-
-    fn sighash(
-        psbt: &psbt::PartiallySignedTransaction,
-        input_index: usize,
-        extra: Self::Extra,
-    ) -> Result<(Self::Sighash, SchnorrSighashType), SignerError> {
-        if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
-            return Err(SignerError::InputIndexOutOfRange);
-        }
-
-        let psbt_input = &psbt.inputs[input_index];
-
-        let sighash_type = psbt_input
-            .sighash_type
-            .unwrap_or_else(|| SchnorrSighashType::Default.into())
-            .schnorr_hash_ty()
-            .map_err(|_| SignerError::InvalidSighash)?;
-        let witness_utxos = psbt
-            .inputs
-            .iter()
-            .cloned()
-            .map(|i| i.witness_utxo)
-            .collect::<Vec<_>>();
-        let mut all_witness_utxos = vec![];
-
-        let mut cache = sighash::SighashCache::new(&psbt.unsigned_tx);
-        let is_anyone_can_pay = psbt::PsbtSighashType::from(sighash_type).to_u32() & 0x80 != 0;
-        let prevouts = if is_anyone_can_pay {
-            sighash::Prevouts::One(
-                input_index,
-                witness_utxos[input_index]
-                    .as_ref()
-                    .ok_or(SignerError::MissingWitnessUtxo)?,
-            )
-        } else if witness_utxos.iter().all(Option::is_some) {
-            all_witness_utxos.extend(witness_utxos.iter().filter_map(|x| x.as_ref()));
-            sighash::Prevouts::All(&all_witness_utxos)
-        } else {
-            return Err(SignerError::MissingWitnessUtxo);
-        };
-
-        // Assume no OP_CODESEPARATOR
-        let extra = extra.map(|leaf_hash| (leaf_hash, 0xFFFFFFFF));
-
-        Ok((
-            cache.taproot_signature_hash(input_index, &prevouts, None, extra, sighash_type)?,
-            sighash_type,
-        ))
-    }
-}
-
 impl PartialOrd for SignersContainerKey {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
@@ -923,11 +640,12 @@ mod signers_container_tests {
     use crate::keys::{DescriptorKey, IntoDescriptorKey};
     use bitcoin::secp256k1::{All, Secp256k1};
     use bitcoin::util::bip32;
+    use bitcoin::util::psbt::PartiallySignedTransaction;
     use bitcoin::Network;
     use miniscript::ScriptContext;
     use std::str::FromStr;
 
-    fn is_equal(this: &Arc<dyn TransactionSigner>, that: &Arc<DummySigner>) -> bool {
+    fn is_equal(this: &Arc<dyn Signer>, that: &Arc<DummySigner>) -> bool {
         let secp = Secp256k1::new();
         this.id(&secp) == that.id(&secp)
     }
@@ -942,11 +660,11 @@ mod signers_container_tests {
         let (prvkey1, _, _) = setup_keys(TPRV0_STR);
         let (prvkey2, _, _) = setup_keys(TPRV1_STR);
         let desc = descriptor!(sh(multi(2, prvkey1, prvkey2))).unwrap();
-        let (wallet_desc, keymap) = desc
+        let (_, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
 
-        let signers = SignersContainer::build(keymap, &wallet_desc, &secp);
+        let signers = SignersContainer::from(keymap);
         assert_eq!(signers.ids().len(), 2);
 
         let signers = signers.signers();
@@ -1008,20 +726,23 @@ mod signers_container_tests {
         number: u64,
     }
 
-    impl SignerCommon for DummySigner {
-        fn id(&self, _secp: &SecpCtx) -> SignerId {
-            SignerId::Dummy(self.number)
-        }
-    }
-
-    impl TransactionSigner for DummySigner {
-        fn sign_transaction(
+    impl Signer for DummySigner {
+        fn sign(
             &self,
-            _psbt: &mut psbt::PartiallySignedTransaction,
+            _psbt: &mut PartiallySignedTransaction,
+            _input_index: Option<usize>,
             _secp: &SecpCtx,
         ) -> Result<(), SignerError> {
             Ok(())
         }
+
+        fn id(&self, _secp: &SecpCtx) -> SignerId {
+            SignerId::Dummy(self.number)
+        }
+
+        fn sign_whole_tx(&self) -> bool {
+            true
+        }
     }
 
     const TPRV0_STR:&str = "tprv8ZgxMBicQKsPdZXrcHNLf5JAJWFAoJ2TrstMRdSKtEggz6PddbuSkvHKM9oKJyFgZV1B7rw8oChspxyYbtmEXYyg1AjfWbL3ho3XHDpHRZf";
@@ -1035,7 +756,7 @@ mod signers_container_tests {
         let secp: Secp256k1<All> = Secp256k1::new();
         let path = bip32::DerivationPath::from_str(PATH).unwrap();
         let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
-        let tpub = bip32::ExtendedPubKey::from_priv(&secp, &tprv);
+        let tpub = bip32::ExtendedPubKey::from_private(&secp, &tprv);
         let fingerprint = tprv.fingerprint(&secp);
         let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
         let pubkey = (tpub, path).into_descriptor_key().unwrap();

src/wallet/tx_builder.rs

@@ -42,7 +42,7 @@ use std::default::Default;
 use std::marker::PhantomData;
 
 use bitcoin::util::psbt::{self, PartiallySignedTransaction as Psbt};
-use bitcoin::{OutPoint, Script, Transaction};
+use bitcoin::{OutPoint, Script, SigHashType, Transaction};
 
 use miniscript::descriptor::DescriptorTrait;
 
@@ -103,7 +103,10 @@ impl TxBuilderContext for BumpFee {}
 ///     builder.finish()?
 /// };
 ///
-/// assert_eq!(psbt1.unsigned_tx.output[..2], psbt2.unsigned_tx.output[..2]);
+/// assert_eq!(
+///     psbt1.global.unsigned_tx.output[..2],
+///     psbt2.global.unsigned_tx.output[..2]
+/// );
 /// # Ok::<(), bdk::Error>(())
 /// ```
 ///
@@ -137,7 +140,7 @@ pub(crate) struct TxParams {
     pub(crate) utxos: Vec<WeightedUtxo>,
     pub(crate) unspendable: HashSet<OutPoint>,
     pub(crate) manually_selected_only: bool,
-    pub(crate) sighash: Option<psbt::PsbtSighashType>,
+    pub(crate) sighash: Option<SigHashType>,
     pub(crate) ordering: TxOrdering,
     pub(crate) locktime: Option<u32>,
     pub(crate) rbf: Option<RbfValue>,
@@ -147,7 +150,6 @@ pub(crate) struct TxParams {
     pub(crate) add_global_xpubs: bool,
     pub(crate) include_output_redeem_witness_script: bool,
     pub(crate) bumping_fee: Option<PreviousFee>,
-    pub(crate) current_height: Option<u32>,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -335,9 +337,8 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     /// 1. The `psbt_input` does not contain a `witness_utxo` or `non_witness_utxo`.
     /// 2. The data in `non_witness_utxo` does not match what is in `outpoint`.
     ///
-    /// Note unless you set [`only_witness_utxo`] any non-taproot `psbt_input` you pass to this
-    /// method must have `non_witness_utxo` set otherwise you will get an error when [`finish`]
-    /// is called.
+    /// Note unless you set [`only_witness_utxo`] any `psbt_input` you pass to this method must
+    /// have `non_witness_utxo` set otherwise you will get an error when [`finish`] is called.
     ///
     /// [`only_witness_utxo`]: Self::only_witness_utxo
     /// [`finish`]: Self::finish
@@ -411,7 +412,7 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     /// Sign with a specific sig hash
     ///
     /// **Use this option very carefully**
-    pub fn sighash(&mut self, sighash: psbt::PsbtSighashType) -> &mut Self {
+    pub fn sighash(&mut self, sighash: SigHashType) -> &mut Self {
         self.params.sighash = Some(sighash);
         self
     }
@@ -544,22 +545,6 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
         self.params.rbf = Some(RbfValue::Value(nsequence));
         self
     }
-
-    /// Set the current blockchain height.
-    ///
-    /// This will be used to:
-    /// 1. Set the nLockTime for preventing fee sniping.
-    /// **Note**: This will be ignored if you manually specify a nlocktime using [`TxBuilder::nlocktime`].
-    /// 2. Decide whether coinbase outputs are mature or not. If the coinbase outputs are not
-    ///    mature at `current_height`, we ignore them in the coin selection.
-    ///    If you want to create a transaction that spends immature coinbase inputs, manually
-    ///    add them using [`TxBuilder::add_utxos`].
-    ///
-    /// In both cases, if you don't provide a current height, we use the last sync height.
-    pub fn current_height(&mut self, height: u32) -> &mut Self {
-        self.params.current_height = Some(height);
-        self
-    }
 }
 
 impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, CreateTx> {
@@ -591,9 +576,6 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, C
     /// difference is that it is valid to use `drain_to` without setting any ordinary recipients
     /// with [`add_recipient`] (but it is perfectly fine to add recipients as well).
     ///
-    /// If you choose not to set any recipients, you should either provide the utxos that the
-    /// transaction should spend via [`add_utxos`], or set [`drain_wallet`] to spend all of them.
-    ///
     /// When bumping the fees of a transaction made with this option, you probably want to
     /// use [`allow_shrinking`] to allow this output to be reduced to pay for the extra fees.
     ///
@@ -624,7 +606,6 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, C
     ///
     /// [`allow_shrinking`]: Self::allow_shrinking
     /// [`add_recipient`]: Self::add_recipient
-    /// [`add_utxos`]: Self::add_utxos
     /// [`drain_wallet`]: Self::drain_wallet
     pub fn drain_to(&mut self, script_pubkey: Script) -> &mut Self {
         self.params.drain_to = Some(script_pubkey);
@@ -634,7 +615,7 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, D, Cs, C
 
 // methods supported only by bump_fee
 impl<'a, D: BatchDatabase> TxBuilder<'a, D, DefaultCoinSelectionAlgorithm, BumpFee> {
-    /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this
+    /// Explicitly tells the wallet that it is allowed to reduce the fee of the output matching this
     /// `script_pubkey` in order to bump the transaction fee. Without specifying this the wallet
     /// will attempt to find a change output to shrink instead.
     ///
@@ -857,7 +838,6 @@ mod test {
                 },
                 txout: Default::default(),
                 keychain: KeychainKind::External,
-                is_spent: false,
             },
             LocalUtxo {
                 outpoint: OutPoint {
@@ -866,7 +846,6 @@ mod test {
                 },
                 txout: Default::default(),
                 keychain: KeychainKind::Internal,
-                is_spent: false,
             },
         ]
     }

src/wallet/verify.rs

@@ -17,7 +17,7 @@ use std::fmt;
 use bitcoin::consensus::serialize;
 use bitcoin::{OutPoint, Transaction, Txid};
 
-use crate::blockchain::GetTx;
+use crate::blockchain::Blockchain;
 use crate::database::Database;
 use crate::error::Error;
 
@@ -29,7 +29,7 @@ use crate::error::Error;
 /// Depending on the [capabilities](crate::blockchain::Blockchain::get_capabilities) of the
 /// [`Blockchain`] backend, the method could fail when called with old "historical" transactions or
 /// with unconfirmed transactions that have been evicted from the backend's memory.
-pub fn verify_tx<D: Database, B: GetTx>(
+pub fn verify_tx<D: Database, B: Blockchain>(
     tx: &Transaction,
     database: &D,
     blockchain: &B,
@@ -104,18 +104,43 @@ impl_error!(bitcoinconsensus::Error, Consensus, VerifyError);
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use crate::database::{BatchOperations, MemoryDatabase};
+    use std::collections::HashSet;
+
     use bitcoin::consensus::encode::deserialize;
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::{Transaction, Txid};
 
+    use crate::blockchain::{Blockchain, Capability, Progress};
+    use crate::database::{BatchDatabase, BatchOperations, MemoryDatabase};
+    use crate::FeeRate;
+
+    use super::*;
+
     struct DummyBlockchain;
 
-    impl GetTx for DummyBlockchain {
+    impl Blockchain for DummyBlockchain {
+        fn get_capabilities(&self) -> HashSet<Capability> {
+            Default::default()
+        }
+        fn setup<D: BatchDatabase, P: 'static + Progress>(
+            &self,
+            _database: &mut D,
+            _progress_update: P,
+        ) -> Result<(), Error> {
+            Ok(())
+        }
         fn get_tx(&self, _txid: &Txid) -> Result<Option<Transaction>, Error> {
             Ok(None)
         }
+        fn broadcast(&self, _tx: &Transaction) -> Result<(), Error> {
+            Ok(())
+        }
+        fn get_height(&self) -> Result<u32, Error> {
+            Ok(42)
+        }
+        fn estimate_fee(&self, _target: usize) -> Result<FeeRate, Error> {
+            Ok(FeeRate::default_min_relay_fee())
+        }
     }
 
     #[test]