Bump version to 0.27.0

0c2570ae07 Pin dev-dependency zip to 0.6.3 (Steve Myers)
e83bb7c4dc Bump version to 0.27.0 (Steve Myers)

Pull request description:

  ### Description

  Bump version to 0.27.0.

  ### Notes to the reviewers

  Updating changelog file again.

  ### Checklists

  #### All Submissions:

  * [x] I've signed all my commits
  * [x] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)

ACKs for top commit:
  danielabrozzoni:
    ACK 0c2570ae07

Tree-SHA512: 334e0a6933be18152f266e3622b877ccf67dafadd3a641eaf9ffa4e671babafbedcdaef431e2195aa7e11945f164b8da44bd8a208c8e7287ce87684fb2459787

.github/ISSUE_TEMPLATE/minor_release.md

@@ -34,6 +34,7 @@ Change the `master` branch to the next MINOR+1 version:
 - [ ] Create a new PR branch called `bump_dev_MAJOR_MINOR+1`, eg. `bump_dev_0_22`.
 - [ ] Bump the `bump_dev_MAJOR_MINOR+1` branch to the next development MINOR+1 version.
   - Change the `Cargo.toml` version value to `MAJOR.MINOR+1.0`.
+  - Update the `CHANGELOG.md` file.
   - The commit message should be "Bump version to MAJOR.MINOR+1.0".
 - [ ] Create PR and merge the `bump_dev_MAJOR_MINOR+1` branch to `master`.
   - Title PR "Bump version to MAJOR.MINOR+1.0".

.github/ISSUE_TEMPLATE/patch_release.md

@@ -34,6 +34,7 @@ Change the `master` branch to the new PATCH+1 version:
 - [ ] Create a new PR branch called `bump_dev_MAJOR_MINOR_PATCH+1`, eg. `bump_dev_0_22_1`.
 - [ ] Bump the `bump_dev_MAJOR_MINOR` branch to the next development PATCH+1 version.
   - Change the `Cargo.toml` version value to `MAJOR.MINOR.PATCH+1`.
+  - Update the `CHANGELOG.md` file.
   - The commit message should be "Bump version to MAJOR.MINOR.PATCH+1".
 - [ ] Create PR and merge the `bump_dev_MAJOR_MINOR_PATCH+1` branch to `master`.
   - Title PR "Bump version to MAJOR.MINOR.PATCH+1".

.github/workflows/cont_integration.yml

@@ -10,9 +10,9 @@ jobs:
     strategy:
       matrix:
         rust:
-          - version: 1.60.0 # STABLE
+          - version: 1.65.0 # STABLE
             clippy: true
-          - version: 1.56.1 # MSRV
+          - version: 1.57.0 # MSRV
         features:
           - default
           - minimal
@@ -146,7 +146,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.65.0 # STABLE
       - name: Set profile
         run: rustup set profile minimal
       - name: Add target wasm32
@@ -154,7 +154,7 @@ jobs:
       - name: Update toolchain
         run: rustup update
       - name: Check
-        run: cargo check --target wasm32-unknown-unknown --features use-esplora-async,dev-getrandom-wasm --no-default-features
+        run: cargo check --target wasm32-unknown-unknown --features async-interface,use-esplora-async,dev-getrandom-wasm --no-default-features
 
   fmt:
     name: Rust fmt
@@ -173,13 +173,13 @@ jobs:
       - name: Check fmt
         run: cargo fmt --all -- --config format_code_in_doc_comments=true --check
 
-  test_harware_wallet:
-    runs-on: ubuntu-latest
+  test_hardware_wallet:
+    runs-on: ubuntu-20.04
     strategy:
       matrix:
         rust:
-          - version: 1.60.0 # STABLE
-          - version: 1.56.1 # MSRV
+          - version: 1.65.0 # STABLE
+          - version: 1.57.0 # MSRV
     steps:
     - name: Checkout
       uses: actions/checkout@v3

.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-2022-12-14
       - name: Set profile
         run: rustup set profile minimal
       - name: Update toolchain

CHANGELOG.md

@@ -1,13 +1,143 @@
 # Changelog
-All notable changes to this project prior to release **0.22.0** are documented in this file. Future
-changelog information can be found in each release's git tag and can be viewed with `git tag -ln100 "v*"`.
-Changelog info is also documented on the [GitHub releases](https://github.com/bitcoindevkit/bdk/releases)
-page. See [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
+
+All notable changes to this project can be found here and in each release's git tag and can be viewed with `git tag -ln100 "v*"`. See also [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
+
+Contributors do not need to change this file but do need to add changelog details in their PR descriptions. The person making the next release will collect changelog details from included PRs and edit this file prior to each release.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [v0.21.0] - [v0.20.0]
+## [Unreleased]
+
+## [v0.27.0]
+
+### Summary
+
+A maintenance release with a bump in project MSRV to 1.57.0, updated dependence and a few developer oriented improvements. Improvements include  better error formatting, don't default to async/await for wasm32 and adding derived PartialEq and Eq on SyncTime.
+
+### Changed
+
+- Improve display error formatting #814
+- Don't default to use async/await on wasm32 #831
+- Project MSRV changed from 1.56.1 to 1.57.0 #842
+- Update rust-miniscript dependency to latest bug fix release 9.0 #844
+
+### Added
+
+- Derive PartialEq, Eq on SyncTime #837
+
+## [v0.26.0]
+
+### Summary
+
+This release improves Fulcrum electrum server compatibility and fixes public descriptor template key origin paths. We also snuck in small enhancements to configure the electrum client to validate the domain using SSL and sort TransactionDetails by block height and timestamp.
+  
+### Fixed
+  
+- Make electrum blockchain client `save_tx` function order independent to work with Fulcrum servers. #808
+- Fix wrong testnet key origin path in public descriptor templates. #818
+- Make README.md code examples compile without errors. #820
+
+### Changed
+
+- Bump `hwi` dependency to `0.4.0`. #825
+- Bump `esplora-client` dependency to `0.3` #830
+
+### Added
+  
+- For electrum blockchain client, allow user to configure whether to validate the domain using SSL. #805
+- Implement ordering for `TransactionDetails`. #812
+
+## [v0.25.0]
+
+### Summary
+
+This release fixes slow sync time and big script_pubkeys table with SQLite, the wallet rescan height for the FullyNodedExport and setting the network for keys in the KeyMap when using descriptor templates. Also added are new blockchain and mnemonic examples.
+  
+### Fixed
+  
+- Slow sync time and big script_pubkeys table with SQLite.
+- Wallet rescan height for the FullyNodedExport.
+- Setting the network for keys in the KeyMap when using descriptor templates.
+  
+### Added
+  
+- Examples for connecting to Esplora, Electrum Server, Neutrino and Bitcoin Core.
+- Example for using a mnemonic in a descriptors.
+
+## [v0.24.0]
+
+### Summary
+
+This release contains important dependency updates for `rust-bitcoin` to `0.29` and `rust-miniscript` to `8.0`, plus related crates that also depend on the latest version of `rust-bitcoin`. The release also includes a breaking change to the BDK signer which now produces low-R signatures by default, saving one byte. A bug was found in the `get_checksum` and `get_checksum_bytes` functions, which are now deprecated in favor of fixed versions called `calc_checksum` and `calc_checksum_bytes`. And finally a new `hardware-signer` features was added that re-exports the `hwi` crate, along with a new `hardware_signers.rs` example file.
+   
+### Changed
+
+- Updated dependency versions for `rust-bitcoin` to `0.29` and `rust-miniscript` to `8.0`, plus all related crates. @afilini #770
+- BDK Signer now produces low-R signatures by default, saving one byte. If you want to preserve the original behavior, set allow_grinding in the SignOptions to false. @vladimirfomene #779
+- Deprecated `get_checksum`and `get_checksum_bytes` due to bug where they calculates the checksum of a descriptor that already has a checksum.  Use `calc_checksum` and `calc_checksum_bytes` instead. @evanlinjin #765
+- Remove deprecated "address validators". @afilini #770
+  
+### Added
+
+- New `calc_checksum` and `calc_checksum_bytes`, replace deprecated `get_checksum` and `get_checksum_bytes`. @evanlinjin #765
+- Re-export the hwi crate when the feature hardware-signer is on.  @danielabrozzoni #758
+- New examples/hardware_signer.rs. @danielabrozzoni #758
+- Make psbt module public to expose PsbtUtils trait to downstream projects. @notmandatory #782
+
+## [v0.23.0]
+
+### Summary
+
+This release brings new utilities functions on PSBTs like `fee_amount()` and `fee_rate()` and migrates BDK to use our new external esplora client library.
+As always many bug fixes, docs and tests improvement are also included.
+
+### Changed
+
+- Update electrum-client to 0.11.0 by @afilini in https://github.com/bitcoindevkit/bdk/pull/737
+- Change configs for source-base code coverage by @wszdexdrf in https://github.com/bitcoindevkit/bdk/pull/708
+- Improve docs regarding PSBT finalization by @tnull in https://github.com/bitcoindevkit/bdk/pull/753
+- Update compiler example to a Policy example by @rajarshimaitra in https://github.com/bitcoindevkit/bdk/pull/730
+- Fix the release process by @afilini in https://github.com/bitcoindevkit/bdk/pull/754
+- Remove redundant duplicated keys check by @afilini in https://github.com/bitcoindevkit/bdk/pull/761
+- Remove genesis_block lazy initialization by @shobitb in https://github.com/bitcoindevkit/bdk/pull/756
+- Fix `Wallet::descriptor_checksum` to actually return the checksum by @evanlinjin in https://github.com/bitcoindevkit/bdk/pull/763
+- Use the esplora client crate by @afilini in https://github.com/bitcoindevkit/bdk/pull/764
+
+### Added
+
+- Run code coverage on every PR by @danielabrozzoni in https://github.com/bitcoindevkit/bdk/pull/747
+- Add psbt_signer.rs example by @notmandatory in https://github.com/bitcoindevkit/bdk/pull/744
+- Add fee_amount() and fee_rate() functions to PsbtUtils trait by @notmandatory in https://github.com/bitcoindevkit/bdk/pull/728
+- Add tests to improve coverage by @vladimirfomene in https://github.com/bitcoindevkit/bdk/pull/745
+- Enable signing taproot transactions with only `non_witness_utxos` by @afilini in https://github.com/bitcoindevkit/bdk/pull/757
+- Add datatype for is_spent sqlite column by @vladimirfomene in https://github.com/bitcoindevkit/bdk/pull/713
+- Add vscode filter to gitignore by @evanlinjin in https://github.com/bitcoindevkit/bdk/pull/762
+
+## [v0.22.0]
+
+### Summary
+
+This release brings support for hardware signers on desktop through the HWI library.
+It also includes fixes and improvements which are part of our ongoing effort of integrating
+BDK and LDK together.
+
+### Changed
+
+- FeeRate function name as_sat_vb to as_sat_per_vb. #678
+- Verify signatures after signing. #718
+- Dependency electrum-client to 0.11.0. #737
+
+### Added
+  
+- Functions to create FeeRate from sats/kvbytes and sats/kwu. #678
+- Custom hardware wallet signer HwiSigner in wallet::hardwaresigner module. #682
+- Function allow_dust on TxBuilder. #689
+- Implementation of Deref<Target=UrlClient> for EsploraBlockchain. #722
+- Implementation of Deref<Target=Client> for ElectrumBlockchain #705
+- Implementation of Deref<Target=Client> for RpcBlockchain. #731
+
+## [v0.21.0]
 
 - Add `descriptor::checksum::get_checksum_bytes` method.
 - Add `Excess` enum to handle remaining amount after coin selection.
@@ -20,7 +150,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - New `RpcBlockchain` implementation with various fixes.
 - Return balance in separate categories, namely `confirmed`, `trusted_pending`, `untrusted_pending` & `immature`.
 
-## [v0.20.0] - [v0.19.0]
+## [v0.20.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)
@@ -31,7 +161,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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]
+## [v0.19.0]
 
 - added `OldestFirstCoinSelection` impl to `CoinSelectionAlgorithm`
 - New MSRV set to `1.56`
@@ -47,7 +177,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - 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]
+## [v0.18.0]
 
 - Add `sqlite-bundled` feature for deployments that need a bundled version of sqlite, i.e. for mobile platforms.
 - Added `Wallet::get_signers()`, `Wallet::descriptor_checksum()` and `Wallet::get_address_validators()`, exposed the `AsDerived` trait.
@@ -57,7 +187,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rename `WalletExport` to `FullyNodedExport`, deprecate the former.
 - Bump `miniscript` dependency version to `^6.1`.
 
-## [v0.17.0] - [v0.16.1]
+## [v0.17.0]
 
 - 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`.
@@ -78,45 +208,45 @@ To decouple the `Wallet` from the `Blockchain` we've made major changes:
 - 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]
+## [v0.16.1]
 
 - Pin tokio dependency version to ~1.14 to prevent errors due to their new MSRV 1.49.0
 
-## [v0.16.0] - [v0.15.0]
+## [v0.16.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]
+## [v0.15.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.
 
-## [v0.14.0] - [v0.13.0]
+## [v0.14.0]
 
 - BIP39 implementation dependency, in `keys::bip39` changed from tiny-bip39 to rust-bip39.
 - Add new method on the `TxBuilder` to embed data in the transaction via `OP_RETURN`. To allow that a fix to check the dust only on spendable output has been introduced.
 - Update the `Database` trait to store the last sync timestamp and block height
 - Rename `ConfirmationTime` to `BlockTime`
 
-## [v0.13.0] - [v0.12.0]
+## [v0.13.0]
 
 - Exposed `get_tx()` method from `Database` to `Wallet`.
 
-## [v0.12.0] - [v0.11.0]
+## [v0.12.0]
 
 - Activate `miniscript/use-serde` feature to allow consumers of the library to access it via the re-exported `miniscript` crate.
 - Add support for proxies in `EsploraBlockchain`
 - Added `SqliteDatabase` that implements `Database` backed by a sqlite database using `rusqlite` crate.
 
-## [v0.11.0] - [v0.10.0]
+## [v0.11.0]
 
 - Added `flush` method to the `Database` trait to explicitly flush to disk latest changes on the db.
 
-## [v0.10.0] - [v0.9.0]
+## [v0.10.0]
 
 - Added `RpcBlockchain` in the `AnyBlockchain` struct to allow using Rpc backend where `AnyBlockchain` is used (eg `bdk-cli`)
 - Removed hard dependency on `tokio`.
@@ -130,21 +260,21 @@ To decouple the `Wallet` from the `Blockchain` we've made major changes:
 - Removed `stop_gap` from `Blockchain` trait and added it to only `ElectrumBlockchain` and `EsploraBlockchain` structs.
 - Added a `ureq` backend for use when not using feature `async-interface` or target WASM. `ureq` is a blocking HTTP client.
 
-## [v0.9.0] - [v0.8.0]
+## [v0.9.0]
 
 ### Wallet
 
 - Added Bitcoin core RPC added as blockchain backend
 - Added a `verify` feature that can be enable to verify the unconfirmed txs we download against the consensus rules
 
-## [v0.8.0] - [v0.7.0]
+## [v0.8.0]
 
 ### Wallet
 - Added an option that must be explicitly enabled to allow signing using non-`SIGHASH_ALL` sighashes (#350)
 #### Changed
 `get_address` now returns an `AddressInfo` struct that includes the index and derefs to `Address`.
 
-## [v0.7.0] - [v0.6.0]
+## [v0.7.0]
 
 ### Policy
 #### Changed
@@ -159,7 +289,7 @@ Timelocks are considered (optionally) in building the `satisfaction` field
 - Require and validate `non_witness_utxo` for SegWit signatures by default, can be adjusted with `SignOptions`
 - Replace the opt-in builder option `force_non_witness_utxo` with the opposite `only_witness_utxo`. From now on we will provide the `non_witness_utxo`, unless explicitly asked not to.
 
-## [v0.6.0] - [v0.5.1]
+## [v0.6.0]
 
 ### Misc
 #### Changed
@@ -183,13 +313,13 @@ Timelocks are considered (optionally) in building the `satisfaction` field
 #### Fixed
 - Fixed `coin_select` calculation for UTXOs where `value < fee` that caused over-/underflow errors.
 
-## [v0.5.1] - [v0.5.0]
+## [v0.5.1]
 
 ### Misc
 #### Changed
 - Pin `hyper` to `=0.14.4` to make it compile on Rust 1.45
 
-## [v0.5.0] - [v0.4.0]
+## [v0.5.0]
 
 ### Misc
 #### Changed
@@ -199,7 +329,7 @@ Timelocks are considered (optionally) in building the `satisfaction` field
 #### Changed
 - `FeeRate` constructors `from_sat_per_vb` and `default_min_relay_fee` are now `const` functions
 
-## [v0.4.0] - [v0.3.0]
+## [v0.4.0]
 
 ### Keys
 #### Changed
@@ -228,7 +358,7 @@ Timelocks are considered (optionally) in building the `satisfaction` field
 - Removed unneeded `Result<(), PolicyError>` return type for `Satisfaction::finalize()`
 - Removed the `TooManyItemsSelected` policy error (see commit message for more details)
 
-## [v0.3.0] - [v0.2.0]
+## [v0.3.0]
 
 ### Descriptor
 #### Changed
@@ -265,7 +395,7 @@ final transaction is created by calling `finish` on the builder.
 #### Changed
 - Remove `cli.rs` module, `cli-utils` feature and `repl.rs` example; moved to new [`bdk-cli`](https://github.com/bitcoindevkit/bdk-cli) repository
 
-## [v0.2.0] - [0.1.0-beta.1]
+## [v0.2.0]
 
 ### Project
 #### Added
@@ -493,3 +623,10 @@ final transaction is created by calling `finish` on the builder.
 [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
 [v0.21.0]: https://github.com/bitcoindevkit/bdk/compare/v0.20.0...v0.21.0
+[v0.22.0]: https://github.com/bitcoindevkit/bdk/compare/v0.21.0...v0.22.0
+[v0.23.0]: https://github.com/bitcoindevkit/bdk/compare/v0.22.0...v0.23.0
+[v0.24.0]: https://github.com/bitcoindevkit/bdk/compare/v0.23.0...v0.24.0
+[v0.25.0]: https://github.com/bitcoindevkit/bdk/compare/v0.24.0...v0.25.0
+[v0.26.0]: https://github.com/bitcoindevkit/bdk/compare/v0.25.0...v0.26.0
+[v0.27.0]: https://github.com/bitcoindevkit/bdk/compare/v0.26.0...v0.27.0
+[Unreleased]: https://github.com/bitcoindevkit/bdk/compare/v0.27.0...HEAD

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bdk"
-version = "0.24.0"
+version = "0.27.0"
 edition = "2018"
 authors = ["Alekos Filini <alekos.filini@gmail.com>", "Riccardo Casatta <riccardo@casatta.it>"]
 homepage = "https://bitcoindevkit.org"
@@ -14,7 +14,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 bdk-macros = "^0.6"
 log = "^0.4"
-miniscript = { version = "8.0", features = ["serde"] }
+miniscript = { version = "9.0", features = ["serde"] }
 bitcoin = { version = "0.29.1", features = ["serde", "base64", "rand"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
@@ -23,7 +23,7 @@ rand = "^0.8"
 # Optional dependencies
 sled = { version = "0.34", optional = true }
 electrum-client = { version = "0.12", optional = true }
-esplora-client = { version = "0.2", default-features = false, optional = true }
+esplora-client = { version = "0.3", default-features = false, optional = true }
 rusqlite = { version = "0.27.0", optional = true }
 ahash = { version = "0.7.6", optional = true }
 futures = { version = "0.3", optional = true }
@@ -31,7 +31,7 @@ async-trait = { version = "0.1", optional = true }
 rocksdb = { version = "0.14", default-features = false, features = ["snappy"], optional = true }
 cc = { version = ">=1.0.64", optional = true }
 socks = { version = "0.3", optional = true }
-hwi = { version = "0.3.0", optional = true }
+hwi = { version = "0.5", optional = true, features = [ "use-miniscript"] }
 
 bip39 = { version = "1.0.1", optional = true }
 bitcoinconsensus = { version = "0.19.0-3", optional = true }
@@ -41,7 +41,7 @@ bitcoincore-rpc = { version = "0.16", optional = true }
 
 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tokio = { version = "1", features = ["rt"] }
+tokio = { version = "1", features = ["rt", "macros"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = "0.2"
@@ -106,9 +106,12 @@ dev-getrandom-wasm = ["getrandom/js"]
 [dev-dependencies]
 lazy_static = "1.4"
 env_logger = "0.7"
-electrsd = "0.21"
+electrsd = "0.22"
 # Move back to importing from rust-bitcoin once https://github.com/rust-bitcoin/rust-bitcoin/pull/1342 is released
 base64 = "^0.13"
+assert_matches = "1.5.0"
+# zip versions after 0.6.3 don't work with our MSRV 1.57.0
+zip = "=0.6.3"
 
 [[example]]
 name = "compact_filters_balance"
@@ -138,6 +141,26 @@ name = "hardware_signer"
 path = "examples/hardware_signer.rs"
 required-features = ["electrum", "hardware-signer"]
 
+[[example]]
+name = "electrum_backend"
+path = "examples/electrum_backend.rs"
+required-features = ["electrum"]
+
+[[example]]
+name = "esplora_backend_synchronous"
+path = "examples/esplora_backend_synchronous.rs"
+required-features = ["use-esplora-ureq"]
+
+[[example]]
+name = "esplora_backend_asynchronous"
+path = "examples/esplora_backend_asynchronous.rs"
+required-features = ["use-esplora-reqwest", "reqwest-default-tls", "async-interface"]
+
+[[example]]
+name = "mnemonic_to_descriptors"
+path = "examples/mnemonic_to_descriptors.rs"
+required-features = ["all-keys"]
+
 [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://coveralls.io/github/bitcoindevkit/bdk?branch=master"><img src="https://coveralls.io/repos/github/bitcoindevkit/bdk/badge.svg?branch=master"/></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/2021/12/02/Rust-1.57.0.html"><img alt="Rustc Version 1.57.0+" src="https://img.shields.io/badge/rustc-1.57.0%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>
 
@@ -68,12 +68,13 @@ fn main() -> Result<(), bdk::Error> {
 ```rust
 use bdk::{Wallet, database::MemoryDatabase};
 use bdk::wallet::AddressIndex::New;
+use bdk::bitcoin::Network;
 
 fn main() -> Result<(), bdk::Error> {
     let wallet = Wallet::new(
         "wpkh([c258d2e4/84h/1h/0h]tpubDDYkZojQFQjht8Tm4jsS3iuEmKjTiEGjG6KnuFNKKJb5A6ZUCUZKdvLdSDWofKi4ToRCwb9poe1XdqfUnP4jaJjCB2Zwv11ZLgSbnZSNecE/0/*)",
         Some("wpkh([c258d2e4/84h/1h/0h]tpubDDYkZojQFQjht8Tm4jsS3iuEmKjTiEGjG6KnuFNKKJb5A6ZUCUZKdvLdSDWofKi4ToRCwb9poe1XdqfUnP4jaJjCB2Zwv11ZLgSbnZSNecE/1/*)"),
-        bitcoin::Network::Testnet,
+        Network::Testnet,
         MemoryDatabase::default(),
     )?;
 
@@ -96,14 +97,15 @@ use bdk::electrum_client::Client;
 use bdk::wallet::AddressIndex::New;
 
 use base64;
-use bitcoin::consensus::serialize;
+use bdk::bitcoin::consensus::serialize;
+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/*)"),
-        bitcoin::Network::Testnet,
+        Network::Testnet,
         MemoryDatabase::default(),
     )?;
 
@@ -133,20 +135,21 @@ fn main() -> Result<(), bdk::Error> {
 use bdk::{Wallet, SignOptions, database::MemoryDatabase};
 
 use base64;
-use bitcoin::consensus::deserialize;
+use bdk::bitcoin::consensus::deserialize;
+use bdk::bitcoin::Network;
 
 fn main() -> Result<(), bdk::Error> {
     let wallet = Wallet::new(
         "wpkh([c258d2e4/84h/1h/0h]tprv8griRPhA7342zfRyB6CqeKF8CJDXYu5pgnj1cjL1u2ngKcJha5jjTRimG82ABzJQ4MQe71CV54xfn25BbhCNfEGGJZnxvCDQCd6JkbvxW6h/0/*)",
         Some("wpkh([c258d2e4/84h/1h/0h]tprv8griRPhA7342zfRyB6CqeKF8CJDXYu5pgnj1cjL1u2ngKcJha5jjTRimG82ABzJQ4MQe71CV54xfn25BbhCNfEGGJZnxvCDQCd6JkbvxW6h/1/*)"),
-        bitcoin::Network::Testnet,
+        Network::Testnet,
         MemoryDatabase::default(),
     )?;
 
     let psbt = "...";
     let mut psbt = deserialize(&base64::decode(psbt).unwrap())?;
 
-    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
+    let _finalized = wallet.sign(&mut psbt, SignOptions::default())?;
 
     Ok(())
 }

ci/Dockerfile.ledger

@@ -6,4 +6,4 @@ RUN apt-get install wget -y
 RUN wget "https://github.com/LedgerHQ/speculos/blob/master/apps/nanos%23btc%232.1%231c8db8da.elf?raw=true" -O /speculos/btc.elf
 ADD automation.json /speculos/automation.json
 
-ENTRYPOINT ["python", "./speculos.py", "--automation", "file:automation.json", "--display", "headless", "--vnc-port", "41000", "btc.elf"]
+ENTRYPOINT ["python", "./speculos.py", "--automation", "file:automation.json", "--model", "nanos", "--display", "headless", "--vnc-port", "41000", "btc.elf"]

examples/compiler.rs

@@ -29,7 +29,7 @@ use bdk::wallet::AddressIndex::New;
 use bdk::{KeychainKind, Wallet};
 
 /// Miniscript policy is a high level abstraction of spending conditions. Defined in the
-/// rust-miscript library here  https://docs.rs/miniscript/7.0.0/miniscript/policy/index.html
+/// rust-miniscript library here  https://docs.rs/miniscript/7.0.0/miniscript/policy/index.html
 /// rust-miniscript provides a `compile()` function that can be used to compile any miniscript policy
 /// into a descriptor. This descriptor then in turn can be used in bdk a fully functioning wallet
 /// can be derived from the policy.

examples/electrum_backend.rs

@@ -0,0 +1,87 @@
+use std::str::FromStr;
+
+use bdk::bitcoin::util::bip32::ExtendedPrivKey;
+use bdk::bitcoin::Network;
+use bdk::blockchain::{Blockchain, ElectrumBlockchain};
+use bdk::database::MemoryDatabase;
+use bdk::template::Bip84;
+use bdk::wallet::export::FullyNodedExport;
+use bdk::{KeychainKind, SyncOptions, Wallet};
+
+use bdk::electrum_client::Client;
+use bdk::wallet::AddressIndex;
+use bitcoin::util::bip32;
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Electrum server.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --example electrum_backend` in the root folder.
+fn main() {
+    let network = Network::Testnet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let electrum_url = "ssl://electrum.blockstream.info:60002";
+
+    run(&network, electrum_url, xpriv);
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+fn run(network: &Network, electrum_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    // Apparently it works only with Electrs (not EletrumX)
+    let blockchain = ElectrumBlockchain::from(Client::new(electrum_url).unwrap());
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 6500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 5359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        blockchain.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/esplora_backend_asynchronous.rs

@@ -0,0 +1,93 @@
+use std::str::FromStr;
+
+use bdk::blockchain::Blockchain;
+use bdk::{
+    blockchain::esplora::EsploraBlockchain,
+    database::MemoryDatabase,
+    template::Bip84,
+    wallet::{export::FullyNodedExport, AddressIndex},
+    KeychainKind, SyncOptions, Wallet,
+};
+use bitcoin::{
+    util::bip32::{self, ExtendedPrivKey},
+    Network,
+};
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Esplora server,
+/// using non blocking asynchronous calls with `reqwest`.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --no-default-features --features="use-esplora-reqwest, reqwest-default-tls, async-interface" --example esplora_backend_asynchronous`
+/// in the root folder.
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let network = Network::Signet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let esplora_url = "https://explorer.bc-2.jp/api";
+
+    run(&network, esplora_url, xpriv).await;
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+async fn run(network: &Network, esplora_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    let blockchain = EsploraBlockchain::new(esplora_url, 20);
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet
+        .sync(&blockchain, SyncOptions::default())
+        .await
+        .unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 10500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 9359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        let _ = blockchain.broadcast(&tx);
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/esplora_backend_synchronous.rs

@@ -0,0 +1,89 @@
+use std::str::FromStr;
+
+use bdk::blockchain::Blockchain;
+use bdk::{
+    blockchain::esplora::EsploraBlockchain,
+    database::MemoryDatabase,
+    template::Bip84,
+    wallet::{export::FullyNodedExport, AddressIndex},
+    KeychainKind, SyncOptions, Wallet,
+};
+use bitcoin::{
+    util::bip32::{self, ExtendedPrivKey},
+    Network,
+};
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Esplora server,
+/// using blocking calls with `ureq`.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --features=use-esplora-ureq --example esplora_backend_synchronous`
+/// in the root folder.
+fn main() {
+    let network = Network::Signet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let esplora_url = "https://explorer.bc-2.jp/api";
+
+    run(&network, esplora_url, xpriv);
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+fn run(network: &Network, esplora_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    let blockchain = EsploraBlockchain::new(esplora_url, 20);
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 10500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 9359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        blockchain.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/hardware_signer.rs

@@ -2,6 +2,7 @@ use bdk::bitcoin::{Address, Network};
 use bdk::blockchain::{Blockchain, ElectrumBlockchain};
 use bdk::database::MemoryDatabase;
 use bdk::hwi::{types::HWIChain, HWIClient};
+use bdk::miniscript::{Descriptor, DescriptorPublicKey};
 use bdk::signer::SignerOrdering;
 use bdk::wallet::{hardwaresigner::HWISigner, AddressIndex};
 use bdk::{FeeRate, KeychainKind, SignOptions, SyncOptions, Wallet};
@@ -23,26 +24,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Hold tight, I'm connecting to your hardware wallet...");
 
     // Listing all the available hardware wallet devices...
-    let devices = HWIClient::enumerate()?;
-    let first_device = devices
-        .first()
-        .expect("No devices found. Either plug in a hardware wallet, or start a simulator.");
+    let mut devices = HWIClient::enumerate()?;
+    if devices.is_empty() {
+        panic!("No devices found. Either plug in a hardware wallet, or start a simulator.");
+    }
+    let first_device = devices.remove(0)?;
     // ...and creating a client out of the first one
-    let client = HWIClient::get_client(first_device, true, HWIChain::Test)?;
+    let client = HWIClient::get_client(&first_device, true, HWIChain::Test)?;
     println!("Look what I found, a {}!", first_device.model);
 
     // Getting the HW's public descriptors
-    let descriptors = client.get_descriptors(None)?;
+    let descriptors = client.get_descriptors::<Descriptor<DescriptorPublicKey>>(None)?;
     println!(
         "The hardware wallet's descriptor is: {}",
         descriptors.receive[0]
     );
 
     // Creating a custom signer from the device
-    let custom_signer = HWISigner::from_device(first_device, HWIChain::Test)?;
+    let custom_signer = HWISigner::from_device(&first_device, HWIChain::Test)?;
     let mut wallet = Wallet::new(
-        &descriptors.receive[0],
-        Some(&descriptors.internal[0]),
+        descriptors.receive[0].clone(),
+        Some(descriptors.internal[0].clone()),
         Network::Testnet,
         MemoryDatabase::default(),
     )?;

examples/mnemonic_to_descriptors.rs

@@ -0,0 +1,60 @@
+// 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::util::bip32::DerivationPath;
+use bdk::bitcoin::Network;
+use bdk::descriptor;
+use bdk::descriptor::IntoWalletDescriptor;
+use bdk::keys::bip39::{Language, Mnemonic, WordCount};
+use bdk::keys::{GeneratableKey, GeneratedKey};
+use bdk::miniscript::Tap;
+use bdk::Error as BDK_Error;
+use std::error::Error;
+use std::str::FromStr;
+
+/// This example demonstrates how to generate a mnemonic phrase
+/// using BDK and use that to generate a descriptor string.
+fn main() -> Result<(), Box<dyn Error>> {
+    let secp = Secp256k1::new();
+
+    // In this example we are generating a 12 words mnemonic phrase
+    // but it is also possible generate 15, 18, 21 and 24 words
+    // using their respective `WordCount` variant.
+    let mnemonic: GeneratedKey<_, Tap> =
+        Mnemonic::generate((WordCount::Words12, Language::English))
+            .map_err(|_| BDK_Error::Generic("Mnemonic generation error".to_string()))?;
+
+    println!("Mnemonic phrase: {}", *mnemonic);
+    let mnemonic_with_passphrase = (mnemonic, None);
+
+    // define external and internal derivation key path
+    let external_path = DerivationPath::from_str("m/86h/0h/0h/0").unwrap();
+    let internal_path = DerivationPath::from_str("m/86h/0h/0h/1").unwrap();
+
+    // generate external and internal descriptor from mnemonic
+    let (external_descriptor, ext_keymap) =
+        descriptor!(tr((mnemonic_with_passphrase.clone(), external_path)))?
+            .into_wallet_descriptor(&secp, Network::Testnet)?;
+    let (internal_descriptor, int_keymap) =
+        descriptor!(tr((mnemonic_with_passphrase, internal_path)))?
+            .into_wallet_descriptor(&secp, Network::Testnet)?;
+
+    println!("tpub external descriptor: {}", external_descriptor);
+    println!("tpub internal descriptor: {}", internal_descriptor);
+    println!(
+        "tprv external descriptor: {}",
+        external_descriptor.to_string_with_secret(&ext_keymap)
+    );
+    println!(
+        "tprv internal descriptor: {}",
+        internal_descriptor.to_string_with_secret(&int_keymap)
+    );
+
+    Ok(())
+}

examples/utils/mod.rs

@@ -0,0 +1,30 @@
+pub(crate) mod tx {
+
+    use std::str::FromStr;
+
+    use bdk::{database::BatchDatabase, SignOptions, Wallet};
+    use bitcoin::{Address, Transaction};
+
+    pub fn build_signed_tx<D: BatchDatabase>(
+        wallet: &Wallet<D>,
+        recipient_address: &str,
+        amount: u64,
+    ) -> Transaction {
+        // Create a transaction builder
+        let mut tx_builder = wallet.build_tx();
+
+        let to_address = Address::from_str(recipient_address).unwrap();
+
+        // Set recipient of the transaction
+        tx_builder.set_recipients(vec![(to_address.script_pubkey(), amount)]);
+
+        // Finalise the transaction and extract PSBT
+        let (mut psbt, _) = tx_builder.finish().unwrap();
+
+        // Sign the above psbt with signing option
+        wallet.sign(&mut psbt, SignOptions::default()).unwrap();
+
+        // Extract the final transaction
+        psbt.extract_tx()
+    }
+}

macros/src/lib.rs

@@ -19,7 +19,7 @@ use syn::{parse, ImplItemMethod, ItemImpl, ItemTrait, Token};
 
 fn add_async_trait(mut parsed: ItemTrait) -> TokenStream {
     let output = quote! {
-        #[cfg(all(not(target_arch = "wasm32"), not(feature = "async-interface")))]
+        #[cfg(not(feature = "async-interface"))]
         #parsed
     };
 
@@ -32,7 +32,7 @@ fn add_async_trait(mut parsed: ItemTrait) -> TokenStream {
     let output = quote! {
         #output
 
-        #[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+        #[cfg(feature = "async-interface")]
         #[async_trait(?Send)]
         #parsed
     };
@@ -42,7 +42,7 @@ fn add_async_trait(mut parsed: ItemTrait) -> TokenStream {
 
 fn add_async_method(mut parsed: ImplItemMethod) -> TokenStream {
     let output = quote! {
-        #[cfg(all(not(target_arch = "wasm32"), not(feature = "async-interface")))]
+        #[cfg(not(feature = "async-interface"))]
         #parsed
     };
 
@@ -51,7 +51,7 @@ fn add_async_method(mut parsed: ImplItemMethod) -> TokenStream {
     let output = quote! {
         #output
 
-        #[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+        #[cfg(feature = "async-interface")]
         #parsed
     };
 
@@ -60,7 +60,7 @@ fn add_async_method(mut parsed: ImplItemMethod) -> TokenStream {
 
 fn add_async_impl_trait(mut parsed: ItemImpl) -> TokenStream {
     let output = quote! {
-        #[cfg(all(not(target_arch = "wasm32"), not(feature = "async-interface")))]
+        #[cfg(not(feature = "async-interface"))]
         #parsed
     };
 
@@ -73,7 +73,7 @@ fn add_async_impl_trait(mut parsed: ItemImpl) -> TokenStream {
     let output = quote! {
         #output
 
-        #[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+        #[cfg(feature = "async-interface")]
         #[async_trait(?Send)]
         #parsed
     };
@@ -81,7 +81,7 @@ fn add_async_impl_trait(mut parsed: ItemImpl) -> TokenStream {
     output.into()
 }
 
-/// Makes a method or every method of a trait "async" only if the target_arch is "wasm32"
+/// Makes a method or every method of a trait `async`, if the `async-interface` feature is enabled.
 ///
 /// Requires the `async-trait` crate as a dependency whenever this attribute is used on a trait
 /// definition or trait implementation.
@@ -101,18 +101,18 @@ pub fn maybe_async(_attr: TokenStream, item: TokenStream) -> TokenStream {
     }
 }
 
-/// Awaits if target_arch is "wasm32", does nothing otherwise
+/// Awaits, if the `async-interface` feature is enabled.
 #[proc_macro]
 pub fn maybe_await(expr: TokenStream) -> TokenStream {
     let expr: proc_macro2::TokenStream = expr.into();
     let quoted = quote! {
         {
-            #[cfg(all(not(target_arch = "wasm32"), not(feature = "async-interface")))]
+            #[cfg(not(feature = "async-interface"))]
             {
                 #expr
             }
 
-            #[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+            #[cfg(feature = "async-interface")]
             {
                 #expr.await
             }
@@ -122,20 +122,20 @@ pub fn maybe_await(expr: TokenStream) -> TokenStream {
     quoted.into()
 }
 
-/// Awaits if target_arch is "wasm32", uses `tokio::Runtime::block_on()` otherwise
+/// Awaits, if the `async-interface` feature is enabled, uses `tokio::Runtime::block_on()` otherwise
 ///
-/// Requires the `tokio` crate as a dependecy with `rt-core` or `rt-threaded` to build on non-wasm32 platforms.
+/// Requires the `tokio` crate as a dependecy with `rt-core` or `rt-threaded` to build.
 #[proc_macro]
 pub fn await_or_block(expr: TokenStream) -> TokenStream {
     let expr: proc_macro2::TokenStream = expr.into();
     let quoted = quote! {
         {
-            #[cfg(all(not(target_arch = "wasm32"), not(feature = "async-interface")))]
+            #[cfg(not(feature = "async-interface"))]
             {
                 tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(#expr)
             }
 
-            #[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+            #[cfg(feature = "async-interface")]
             {
                 #expr.await
             }

src/blockchain/any.rs

@@ -131,7 +131,7 @@ impl GetBlockHash for AnyBlockchain {
 impl WalletSync for AnyBlockchain {
     fn wallet_sync<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         maybe_await!(impl_inner_method!(
@@ -144,7 +144,7 @@ impl WalletSync for AnyBlockchain {
 
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         maybe_await!(impl_inner_method!(
@@ -178,7 +178,8 @@ impl_from!(boxed rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]
 ///    "type" : "electrum",
 ///    "url" : "ssl://electrum.blockstream.info:50002",
 ///    "retry": 2,
-///    "stop_gap": 20
+///    "stop_gap": 20,
+///    "validate_domain": true
 /// }"#,
 /// )
 /// .unwrap();
@@ -190,6 +191,7 @@ impl_from!(boxed rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]
 ///         socks5: None,
 ///         timeout: None,
 ///         stop_gap: 20,
+///         validate_domain: true,
 ///     })
 /// );
 /// # }

src/blockchain/compact_filters/mod.rs

@@ -51,6 +51,7 @@
 
 use std::collections::HashSet;
 use std::fmt;
+use std::ops::DerefMut;
 use std::path::Path;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
@@ -274,7 +275,7 @@ impl WalletSync for CompactFiltersBlockchain {
     #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         let first_peer = &self.peers[0];
@@ -322,6 +323,9 @@ impl WalletSync for CompactFiltersBlockchain {
 
         cf_sync.prepare_sync(Arc::clone(first_peer))?;
 
+        let mut database = database.borrow_mut();
+        let database = database.deref_mut();
+
         let all_scripts = Arc::new(
             database
                 .iter_script_pubkeys(None)?
@@ -576,7 +580,27 @@ pub enum CompactFiltersError {
 
 impl fmt::Display for CompactFiltersError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::InvalidResponse => write!(f, "A peer sent an invalid or unexpected response"),
+            Self::InvalidHeaders => write!(f, "Invalid headers"),
+            Self::InvalidFilterHeader => write!(f, "Invalid filter header"),
+            Self::InvalidFilter => write!(f, "Invalid filters"),
+            Self::MissingBlock => write!(f, "The peer is missing a block in the valid chain"),
+            Self::BlockHashNotFound => write!(f, "Block hash not found"),
+            Self::DataCorruption => write!(
+                f,
+                "The data stored in the block filters storage are corrupted"
+            ),
+            Self::NotConnected => write!(f, "A peer is not connected"),
+            Self::Timeout => write!(f, "A peer took too long to reply to one of our messages"),
+            Self::PeerBloomDisabled => write!(f, "Peer doesn't advertise the BLOOM service flag"),
+            Self::NoPeers => write!(f, "No peers have been specified"),
+            Self::Db(err) => write!(f, "Internal database error: {}", err),
+            Self::Io(err) => write!(f, "Internal I/O error: {}", err),
+            Self::Bip158(err) => write!(f, "Invalid BIP158 filter: {}", err),
+            Self::Time(err) => write!(f, "Invalid system time: {}", err),
+            Self::Global(err) => write!(f, "Generic error: {}", err),
+        }
     }
 }
 

src/blockchain/compact_filters/store.rs

@@ -233,7 +233,7 @@ impl ChainStore<Full> {
             batch.put_cf(
                 cf_handle,
                 StoreEntry::BlockHeaderIndex(Some(genesis.block_hash())).get_key(),
-                &0usize.to_be_bytes(),
+                0usize.to_be_bytes(),
             );
             store.write(batch)?;
         }
@@ -302,7 +302,7 @@ impl ChainStore<Full> {
         batch.put_cf(
             new_cf_handle,
             StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
-            &from.to_be_bytes(),
+            from.to_be_bytes(),
         );
         batch.put_cf(
             new_cf_handle,
@@ -584,7 +584,7 @@ impl<T: StoreType> ChainStore<T> {
             batch.put_cf(
                 cf_handle,
                 StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
-                &(height).to_be_bytes(),
+                (height).to_be_bytes(),
             );
             batch.put_cf(
                 cf_handle,

src/blockchain/compact_filters/sync.rs

@@ -136,7 +136,7 @@ impl CfSync {
 
                 let resp = peer.get_cf_headers(0x00, start_height as u32, stop_hash)?;
 
-                assert!(resp.previous_filter_header == checkpoint);
+                assert_eq!(resp.previous_filter_header, checkpoint);
                 status =
                     self.cf_store
                         .advance_to_cf_headers(index, checkpoint, resp.filter_hashes)?;

src/blockchain/electrum.rs

@@ -25,7 +25,7 @@
 //! ```
 
 use std::collections::{HashMap, HashSet};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
@@ -117,9 +117,11 @@ impl GetBlockHash for ElectrumBlockchain {
 impl WalletSync for ElectrumBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         _progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
+        let mut database = database.borrow_mut();
+        let database = database.deref_mut();
         let mut request = script_sync::start(database, self.stop_gap)?;
         let mut block_times = HashMap::<u32, u32>::new();
         let mut txid_to_height = HashMap::<Txid, u32>::new();
@@ -281,9 +283,11 @@ impl<'a, 'b, D: Database> TxCache<'a, 'b, D> {
                 .client
                 .batch_transaction_get(need_fetch.clone())
                 .map_err(Error::Electrum)?;
-            for (tx, _txid) in txs.into_iter().zip(need_fetch) {
-                debug_assert_eq!(*_txid, tx.txid());
-                self.cache.insert(tx.txid(), tx);
+            let mut txs: HashMap<_, _> = txs.into_iter().map(|tx| (tx.txid(), tx)).collect();
+            for txid in need_fetch {
+                if let Some(tx) = txs.remove(txid) {
+                    self.cache.insert(*txid, tx);
+                }
             }
         }
 
@@ -310,6 +314,8 @@ pub struct ElectrumBlockchainConfig {
     pub timeout: Option<u8>,
     /// Stop searching addresses for transactions after finding an unused gap of this length
     pub stop_gap: usize,
+    /// Validate the domain when using SSL
+    pub validate_domain: bool,
 }
 
 impl ConfigurableBlockchain for ElectrumBlockchain {
@@ -321,6 +327,7 @@ impl ConfigurableBlockchain for ElectrumBlockchain {
             .retry(config.retry)
             .timeout(config.timeout)?
             .socks5(socks5)?
+            .validate_domain(config.validate_domain)
             .build();
 
         Ok(ElectrumBlockchain {
@@ -415,6 +422,7 @@ mod test {
                     retry: 0,
                     timeout: None,
                     stop_gap: stop_gap,
+                    validate_domain: true,
                 })
             }
         }

src/blockchain/esplora/async.rs

@@ -12,7 +12,7 @@
 //! Esplora by way of `reqwest` HTTP client.
 
 use std::collections::{HashMap, HashSet};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 use bitcoin::{Transaction, Txid};
 
@@ -135,10 +135,12 @@ impl GetBlockHash for EsploraBlockchain {
 impl WalletSync for EsploraBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         _progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         use crate::blockchain::script_sync::Request;
+        let mut database = database.borrow_mut();
+        let database = database.deref_mut();
         let mut request = script_sync::start(database, self.stop_gap)?;
         let mut tx_index: HashMap<Txid, Tx> = HashMap::new();
 

src/blockchain/esplora/blocking.rs

@@ -12,6 +12,7 @@
 //! Esplora by way of `ureq` HTTP client.
 
 use std::collections::{HashMap, HashSet};
+use std::ops::DerefMut;
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
@@ -117,10 +118,12 @@ impl GetBlockHash for EsploraBlockchain {
 impl WalletSync for EsploraBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         _progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         use crate::blockchain::script_sync::Request;
+        let mut database = database.borrow_mut();
+        let database = database.deref_mut();
         let mut request = script_sync::start(database, self.stop_gap)?;
         let mut tx_index: HashMap<Txid, Tx> = HashMap::new();
         let batch_update = loop {

src/blockchain/mod.rs

@@ -16,6 +16,7 @@
 //! [Compact Filters/Neutrino](crate::blockchain::compact_filters), along with a generalized trait
 //! [`Blockchain`] that can be implemented to build customized backends.
 
+use std::cell::RefCell;
 use std::collections::HashSet;
 use std::ops::Deref;
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -133,7 +134,7 @@ pub trait WalletSync {
     /// Populate the internal database with transactions and UTXOs
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error>;
 
@@ -156,7 +157,7 @@ pub trait WalletSync {
     /// [`BatchOperations::del_utxo`]: crate::database::BatchOperations::del_utxo
     fn wallet_sync<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         maybe_await!(self.wallet_setup(database, progress_update))
@@ -248,11 +249,8 @@ pub trait BlockchainFactory {
     /// 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"))))
-    )]
+    #[cfg(not(feature = "async-interface"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "async-interface"))))]
     fn sync_wallet<D: BatchDatabase>(
         &self,
         wallet: &Wallet<D>,
@@ -377,7 +375,7 @@ impl<T: GetBlockHash> GetBlockHash for Arc<T> {
 impl<T: WalletSync> WalletSync for Arc<T> {
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         maybe_await!(self.deref().wallet_setup(database, progress_update))
@@ -385,7 +383,7 @@ impl<T: WalletSync> WalletSync for Arc<T> {
 
     fn wallet_sync<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn Progress>,
     ) -> Result<(), Error> {
         maybe_await!(self.deref().wallet_sync(database, progress_update))

src/blockchain/rpc.rs

@@ -49,8 +49,9 @@ use bitcoincore_rpc::Auth as RpcAuth;
 use bitcoincore_rpc::{Client, RpcApi};
 use log::{debug, info};
 use serde::{Deserialize, Serialize};
+use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
 use std::thread;
 use std::time::Duration;
@@ -192,10 +193,12 @@ impl GetBlockHash for RpcBlockchain {
 }
 
 impl WalletSync for RpcBlockchain {
-    fn wallet_setup<D>(&self, db: &mut D, prog: Box<dyn Progress>) -> Result<(), Error>
+    fn wallet_setup<D>(&self, db: &RefCell<D>, prog: Box<dyn Progress>) -> Result<(), Error>
     where
         D: BatchDatabase,
     {
+        let mut db = db.borrow_mut();
+        let db = db.deref_mut();
         let batch = DbState::new(db, &self.sync_params, &*prog)?
             .sync_with_core(&self.client, self.is_descriptors)?
             .as_db_batch()?;

src/database/mod.rs

@@ -49,7 +49,7 @@ pub use memory::MemoryDatabase;
 /// Blockchain state at the time of syncing
 ///
 /// Contains only the block time and height at the moment
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct SyncTime {
     /// Block timestamp and height at the time of sync
     pub block_time: BlockTime,

src/database/sqlite.rs

@@ -57,7 +57,17 @@ static MIGRATIONS: &[&str] = &[
     "CREATE TABLE utxos (value INTEGER, keychain TEXT, vout INTEGER, txid BLOB, script BLOB, is_spent BOOLEAN DEFAULT 0);",
     "INSERT INTO utxos SELECT value, keychain, vout, txid, script, is_spent FROM utxos_old;",
     "DROP TABLE utxos_old;",
-    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);"
+    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);",
+    // Fix issue https://github.com/bitcoindevkit/bdk/issues/801: drop duplicated script_pubkeys
+    "ALTER TABLE script_pubkeys RENAME TO script_pubkeys_old;",
+    "DROP INDEX idx_keychain_child;",
+    "DROP INDEX idx_script;",
+    "CREATE TABLE script_pubkeys (keychain TEXT, child INTEGER, script BLOB);",
+    "CREATE INDEX idx_keychain_child ON script_pubkeys(keychain, child);",
+    "CREATE INDEX idx_script ON script_pubkeys(script);",
+    "CREATE UNIQUE INDEX idx_script_pks_unique ON script_pubkeys(keychain, child);",
+    "INSERT OR REPLACE INTO script_pubkeys SELECT keychain, child, script FROM script_pubkeys_old;",
+    "DROP TABLE script_pubkeys_old;"
 ];
 
 /// Sqlite database stored on filesystem
@@ -88,7 +98,7 @@ impl SqliteDatabase {
         child: u32,
         script: &[u8],
     ) -> Result<i64, Error> {
-        let mut statement = self.connection.prepare_cached("INSERT INTO script_pubkeys (keychain, child, script) VALUES (:keychain, :child, :script)")?;
+        let mut statement = self.connection.prepare_cached("INSERT OR REPLACE INTO script_pubkeys (keychain, child, script) VALUES (:keychain, :child, :script)")?;
         statement.execute(named_params! {
             ":keychain": keychain,
             ":child": child,
@@ -1096,4 +1106,42 @@ pub mod test {
     fn test_check_descriptor_checksum() {
         crate::database::test::test_check_descriptor_checksum(get_database());
     }
+
+    // Issue 801: https://github.com/bitcoindevkit/bdk/issues/801
+    #[test]
+    fn test_unique_spks() {
+        use crate::bitcoin::hashes::hex::FromHex;
+        use crate::database::*;
+
+        let mut db = get_database();
+
+        let script = Script::from(
+            Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
+        );
+        let path = 42;
+        let keychain = KeychainKind::External;
+
+        for _ in 0..100 {
+            db.set_script_pubkey(&script, keychain, path).unwrap();
+        }
+
+        let mut statement = db
+            .connection
+            .prepare_cached(
+                "select keychain,child,count(child) from script_pubkeys group by keychain,child;",
+            )
+            .unwrap();
+        let mut rows = statement.query([]).unwrap();
+        while let Some(row) = rows.next().unwrap() {
+            let keychain: String = row.get(0).unwrap();
+            let child: u32 = row.get(1).unwrap();
+            let count: usize = row.get(2).unwrap();
+
+            assert_eq!(
+                count, 1,
+                "keychain={}, child={}, count={}",
+                keychain, child, count
+            );
+        }
+    }
 }

src/descriptor/checksum.rs

@@ -133,6 +133,7 @@ pub fn get_checksum(desc: &str) -> Result<String, DescriptorError> {
 mod test {
     use super::*;
     use crate::descriptor::calc_checksum;
+    use assert_matches::assert_matches;
 
     // test calc_checksum() function; it should return the same value as Bitcoin Core
     #[test]
@@ -155,16 +156,16 @@ mod test {
         assert_eq!(calc_checksum(desc).unwrap(), "lasegmfs");
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#tqz0nc26";
-        assert!(matches!(
-            calc_checksum(desc).err(),
-            Some(DescriptorError::InvalidDescriptorChecksum)
-        ));
+        assert_matches!(
+            calc_checksum(desc),
+            Err(DescriptorError::InvalidDescriptorChecksum)
+        );
 
         let desc = "pkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/44'/1'/0'/0/*)#lasegmsf";
-        assert!(matches!(
-            calc_checksum(desc).err(),
-            Some(DescriptorError::InvalidDescriptorChecksum)
-        ));
+        assert_matches!(
+            calc_checksum(desc),
+            Err(DescriptorError::InvalidDescriptorChecksum)
+        );
     }
 
     #[test]
@@ -172,9 +173,9 @@ mod test {
         let sparkle_heart = unsafe { std::str::from_utf8_unchecked(&[240, 159, 146, 150]) };
         let invalid_desc = format!("wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcL{}fjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)", sparkle_heart);
 
-        assert!(matches!(
-            calc_checksum(&invalid_desc).err(),
-            Some(DescriptorError::InvalidDescriptorCharacter(invalid_char)) if invalid_char == sparkle_heart.as_bytes()[0]
-        ));
+        assert_matches!(
+            calc_checksum(&invalid_desc),
+            Err(DescriptorError::InvalidDescriptorCharacter(invalid_char)) if invalid_char == sparkle_heart.as_bytes()[0]
+        );
     }
 }

src/descriptor/error.rs

@@ -53,7 +53,26 @@ impl From<crate::keys::KeyError> for Error {
 
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::InvalidHdKeyPath => write!(f, "Invalid HD key path"),
+            Self::InvalidDescriptorChecksum => {
+                write!(f, "The provided descriptor doesn't match its checksum")
+            }
+            Self::HardenedDerivationXpub => write!(
+                f,
+                "The descriptor contains hardened derivation steps on public extended keys"
+            ),
+            Self::Key(err) => write!(f, "Key error: {}", err),
+            Self::Policy(err) => write!(f, "Policy error: {}", err),
+            Self::InvalidDescriptorCharacter(char) => {
+                write!(f, "Invalid descriptor character: {}", char)
+            }
+            Self::Bip32(err) => write!(f, "BIP32 error: {}", err),
+            Self::Base58(err) => write!(f, "Base58 error: {}", err),
+            Self::Pk(err) => write!(f, "Key-related error: {}", err),
+            Self::Miniscript(err) => write!(f, "Miniscript error: {}", err),
+            Self::Hex(err) => write!(f, "Hex decoding error: {}", err),
+        }
     }
 }
 

src/descriptor/mod.rs

@@ -21,7 +21,9 @@ use bitcoin::util::{psbt, taproot};
 use bitcoin::{secp256k1, PublicKey, XOnlyPublicKey};
 use bitcoin::{Network, TxOut};
 
-use miniscript::descriptor::{DefiniteDescriptorKey, DescriptorType, InnerXKey, SinglePubKey};
+use miniscript::descriptor::{
+    DefiniteDescriptorKey, DescriptorSecretKey, DescriptorType, InnerXKey, SinglePubKey,
+};
 pub use miniscript::{
     descriptor::DescriptorXKey, descriptor::KeyMap, descriptor::Wildcard, Descriptor,
     DescriptorPublicKey, Legacy, Miniscript, ScriptContext, Segwitv0,
@@ -240,14 +242,34 @@ impl IntoWalletDescriptor for DescriptorTemplateOut {
             );
         }
 
-        if !self.2.contains(&network) {
+        let (desc, keymap, networks) = self;
+
+        if !networks.contains(&network) {
             return Err(DescriptorError::Key(KeyError::InvalidNetwork));
         }
 
-        // fixup the network for keys that need it
-        let translated = self.0.translate_pk(&mut Translator { network })?;
+        // fixup the network for keys that need it in the descriptor
+        let translated = desc.translate_pk(&mut Translator { network })?;
+        // ...and in the key map
+        let fixed_keymap = keymap
+            .into_iter()
+            .map(|(mut k, mut v)| {
+                match (&mut k, &mut v) {
+                    (DescriptorPublicKey::XPub(xpub), DescriptorSecretKey::XPrv(xprv)) => {
+                        xpub.xkey.network = network;
+                        xprv.xkey.network = network;
+                    }
+                    (_, DescriptorSecretKey::Single(key)) => {
+                        key.key.network = network;
+                    }
+                    _ => {}
+                }
 
-        Ok((translated, self.1))
+                (k, v)
+            })
+            .collect();
+
+        Ok((translated, fixed_keymap))
     }
 }
 
@@ -559,6 +581,7 @@ impl DescriptorMeta for ExtendedDescriptor {
 mod test {
     use std::str::FromStr;
 
+    use assert_matches::assert_matches;
     use bitcoin::consensus::encode::deserialize;
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::secp256k1::Secp256k1;
@@ -682,23 +705,40 @@ mod test {
 
         let secp = Secp256k1::new();
 
-        let xpub = bip32::ExtendedPubKey::from_str("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3c3gF1DUWpWNr2SG2XrG8oYPpqYh7hoWsJy9NjabErnzriJPpnGHyKz5NgdXmq1KVbqS1r4NXdCoKitWg5e86zqXHa8kxyB").unwrap();
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
 
         // here `to_descriptor_key` will set the valid networks for the key to only mainnet, since
         // we are using an "xpub"
-        let key = (xpub, path).into_descriptor_key().unwrap();
+        let key = (xprv, path.clone()).into_descriptor_key().unwrap();
         // override it with any. this happens in some key conversions, like bip39
         let key = key.override_valid_networks(any_network());
 
         // make a descriptor out of it
         let desc = crate::descriptor!(wpkh(key)).unwrap();
         // this should convert the key that supports "any_network" to the right network (testnet)
-        let (wallet_desc, _) = desc
+        let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
 
-        assert_eq!(wallet_desc.to_string(), "wpkh(tpubDEnoLuPdBep9bzw5LoGYpsxUQYheRQ9gcgrJhJEcdKFB9cWQRyYmkCyRoTqeD4tJYiVVgt6A3rN6rWn9RYhR9sBsGxji29LYWHuKKbdb1ev/0/*)#y8p7e8kk");
+        let mut xprv_testnet = xprv;
+        xprv_testnet.network = Network::Testnet;
+
+        let xpub_testnet = bip32::ExtendedPubKey::from_priv(&secp, &xprv_testnet);
+        let desc_pubkey = DescriptorPublicKey::XPub(DescriptorXKey {
+            xkey: xpub_testnet,
+            origin: None,
+            derivation_path: path,
+            wildcard: Wildcard::Unhardened,
+        });
+
+        assert_eq!(wallet_desc.to_string(), "wpkh(tpubD6NzVbkrYhZ4XtJzoDja5snUjBNQRP5B3f4Hyn1T1x6PVPxzzVjvw6nJx2D8RBCxog9GEVjZoyStfepTz7TtKoBVdkCtnc7VCJh9dD4RAU9/0/*)#a3svx0ha");
+        assert_eq!(
+            keymap
+                .get(&desc_pubkey)
+                .map(|key| key.to_public(&secp).unwrap()),
+            Some(desc_pubkey)
+        );
     }
 
     // test IntoWalletDescriptor trait from &str with and without checksum appended
@@ -724,17 +764,11 @@ mod test {
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#67ju93jw"
             .into_wallet_descriptor(&secp, Network::Testnet);
-        assert!(matches!(
-            desc.err(),
-            Some(DescriptorError::InvalidDescriptorChecksum)
-        ));
+        assert_matches!(desc, Err(DescriptorError::InvalidDescriptorChecksum));
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#67ju93jw"
             .into_wallet_descriptor(&secp, Network::Testnet);
-        assert!(matches!(
-            desc.err(),
-            Some(DescriptorError::InvalidDescriptorChecksum)
-        ));
+        assert_matches!(desc, Err(DescriptorError::InvalidDescriptorChecksum));
     }
 
     // test IntoWalletDescriptor trait from &str with keys from right and wrong network
@@ -768,17 +802,11 @@ mod test {
 
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)"
             .into_wallet_descriptor(&secp, Network::Bitcoin);
-        assert!(matches!(
-            desc.err(),
-            Some(DescriptorError::Key(KeyError::InvalidNetwork))
-        ));
+        assert_matches!(desc, Err(DescriptorError::Key(KeyError::InvalidNetwork)));
 
         let desc = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/2/*)"
             .into_wallet_descriptor(&secp, Network::Bitcoin);
-        assert!(matches!(
-            desc.err(),
-            Some(DescriptorError::Key(KeyError::InvalidNetwork))
-        ));
+        assert_matches!(desc, Err(DescriptorError::Key(KeyError::InvalidNetwork)));
     }
 
     // test IntoWalletDescriptor trait from the output of the descriptor!() macro
@@ -812,11 +840,7 @@ mod test {
         let descriptor = "wpkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0'/1/2/*)";
         let result = into_wallet_descriptor_checked(descriptor, &secp, Network::Testnet);
 
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            DescriptorError::HardenedDerivationXpub
-        ));
+        assert_matches!(result, Err(DescriptorError::HardenedDerivationXpub));
 
         let descriptor = "wsh(multi(2,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0/*,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0/*))";
         let result = into_wallet_descriptor_checked(descriptor, &secp, Network::Testnet);

src/descriptor/policy.rs

@@ -512,7 +512,14 @@ pub enum PolicyError {
 
 impl fmt::Display for PolicyError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::NotEnoughItemsSelected(err) => write!(f, "Not enought items selected: {}", err),
+            Self::IndexOutOfRange(index) => write!(f, "Index out of range: {}", index),
+            Self::AddOnLeaf => write!(f, "Add on leaf"),
+            Self::AddOnPartialComplete => write!(f, "Add on partial complete"),
+            Self::MixedTimelockUnits => write!(f, "Mixed timelock units"),
+            Self::IncompatibleConditions => write!(f, "Incompatible conditions"),
+        }
     }
 }
 
@@ -1139,6 +1146,7 @@ mod test {
     use crate::descriptor::policy::SatisfiableItem::{EcdsaSignature, Multisig, Thresh};
     use crate::keys::{DescriptorKey, IntoDescriptorKey};
     use crate::wallet::signer::SignersContainer;
+    use assert_matches::assert_matches;
     use bitcoin::secp256k1::Secp256k1;
     use bitcoin::util::bip32;
     use bitcoin::Network;
@@ -1182,8 +1190,8 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
-        assert!(matches!(&policy.contribution, Satisfaction::None));
+        assert_matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint);
+        assert_matches!(&policy.contribution, Satisfaction::None);
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
         let (wallet_desc, keymap) = desc
@@ -1195,10 +1203,8 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
-        assert!(
-            matches!(&policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
-        );
+        assert_matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint);
+        assert_matches!(&policy.contribution, Satisfaction::Complete {condition} if condition.csv.is_none() && condition.timelock.is_none());
     }
 
     // 2 pub keys descriptor, required 2 prv keys
@@ -1217,19 +1223,16 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(
-            matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
+        assert_matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[1] == PkOrF::Fingerprint(fingerprint1)
         );
         // TODO should this be "Satisfaction::None" since we have no prv keys?
         // TODO should items and conditions not be empty?
-        assert!(
-            matches!(&policy.contribution, Satisfaction::Partial { n, m, items, conditions, ..} if n == &2usize
+        assert_matches!(&policy.contribution, Satisfaction::Partial { n, m, items, conditions, ..} if n == &2usize
             && m == &2usize
             && items.is_empty()
             && conditions.is_empty()
-            )
         );
     }
 
@@ -1248,18 +1251,15 @@ mod test {
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
-        assert!(
-            matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
+        assert_matches!(&policy.item, Multisig { keys, threshold } if threshold == &2usize
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[1] == PkOrF::Fingerprint(fingerprint1)
         );
 
-        assert!(
-            matches!(&policy.contribution, Satisfaction::Partial { n, m, items, conditions, ..} if n == &2usize
+        assert_matches!(&policy.contribution, Satisfaction::Partial { n, m, items, conditions, ..} if n == &2usize
              && m == &2usize
              && items.len() == 1
              && conditions.contains_key(&0)
-            )
         );
     }
 
@@ -1281,18 +1281,15 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(
-            matches!(&policy.item, Multisig { keys, threshold } if threshold == &1
+        assert_matches!(&policy.item, Multisig { keys, threshold } if threshold == &1
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[1] == PkOrF::Fingerprint(fingerprint1)
         );
-        assert!(
-            matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
+        assert_matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
              && m == &1
              && items.len() == 2
              && conditions.contains_key(&vec![0])
              && conditions.contains_key(&vec![1])
-            )
         );
     }
 
@@ -1313,18 +1310,15 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(
-            matches!(&policy.item, Multisig { keys, threshold } if threshold == &2
+        assert_matches!(&policy.item, Multisig { keys, threshold } if threshold == &2
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[1] == PkOrF::Fingerprint(fingerprint1)
         );
 
-        assert!(
-            matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
+        assert_matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
              && m == &2
              && items.len() == 2
              && conditions.contains_key(&vec![0,1])
-            )
         );
     }
 
@@ -1345,8 +1339,8 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
-        assert!(matches!(&policy.contribution, Satisfaction::None));
+        assert_matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint);
+        assert_matches!(&policy.contribution, Satisfaction::None);
 
         let desc = descriptor!(wpkh(prvkey)).unwrap();
         let (wallet_desc, keymap) = desc
@@ -1358,10 +1352,8 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(matches!(policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == fingerprint));
-        assert!(
-            matches!(policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
-        );
+        assert_matches!(policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == fingerprint);
+        assert_matches!(policy.contribution, Satisfaction::Complete {condition} if condition.csv.is_none() && condition.timelock.is_none());
     }
 
     // single key, 1 prv and 1 pub key descriptor, required 1 prv keys
@@ -1382,18 +1374,15 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(
-            matches!(policy.item, Multisig { keys, threshold } if threshold == 1
+        assert_matches!(policy.item, Multisig { keys, threshold } if threshold == 1
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
-            && keys[1] == PkOrF::Fingerprint(fingerprint1))
+            && keys[1] == PkOrF::Fingerprint(fingerprint1)
         );
-        assert!(
-            matches!(policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == 2
+        assert_matches!(policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == 2
              && m == 1
              && items.len() == 2
              && conditions.contains_key(&vec![0])
              && conditions.contains_key(&vec![1])
-            )
         );
     }
 
@@ -1425,18 +1414,14 @@ mod test {
             .unwrap()
             .unwrap();
 
-        assert!(
-            matches!(&policy.item, Thresh { items, threshold } if items.len() == 3 && threshold == &2)
-        );
+        assert_matches!(&policy.item, Thresh { items, threshold } if items.len() == 3 && threshold == &2);
 
-        assert!(
-            matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &3
+        assert_matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &3
              && m == &2
              && items.len() == 3
              && conditions.get(&vec![0,1]).unwrap().iter().next().unwrap().csv.is_none()
              && conditions.get(&vec![0,2]).unwrap().iter().next().unwrap().csv == Some(Sequence(sequence))
              && conditions.get(&vec![1,2]).unwrap().iter().next().unwrap().csv == Some(Sequence(sequence))
-            )
         );
     }
 
@@ -1599,11 +1584,9 @@ mod test {
             .unwrap();
         //println!("{}", serde_json::to_string(&policy_alice_psbt).unwrap());
 
-        assert!(
-            matches!(&policy_alice_psbt.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &2
+        assert_matches!(&policy_alice_psbt.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &2
              && m == &2
              && items == &vec![0]
-            )
         );
 
         let psbt = Psbt::from_str(BOB_SIGNED_PSBT).unwrap();
@@ -1613,11 +1596,9 @@ mod test {
             .unwrap();
         //println!("{}", serde_json::to_string(&policy_bob_psbt).unwrap());
 
-        assert!(
-            matches!(&policy_bob_psbt.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &2
+        assert_matches!(&policy_bob_psbt.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &2
              && m == &2
              && items == &vec![1]
-            )
         );
 
         let psbt = Psbt::from_str(ALICE_BOB_SIGNED_PSBT).unwrap();
@@ -1625,11 +1606,9 @@ mod test {
             .extract_policy(&signers_container, BuildSatisfaction::Psbt(&psbt), &secp)
             .unwrap()
             .unwrap();
-        assert!(
-            matches!(&policy_alice_bob_psbt.satisfaction, Satisfaction::PartialComplete { n, m, items, .. } if n == &2
+        assert_matches!(&policy_alice_bob_psbt.satisfaction, Satisfaction::PartialComplete { n, m, items, .. } if n == &2
              && m == &2
              && items == &vec![0, 1]
-            )
         );
     }
 
@@ -1673,11 +1652,9 @@ mod test {
             .extract_policy(&signers_container, build_sat, &secp)
             .unwrap()
             .unwrap();
-        assert!(
-            matches!(&policy.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &3
+        assert_matches!(&policy.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &3
              && m == &2
              && items.is_empty()
-            )
         );
         //println!("{}", serde_json::to_string(&policy).unwrap());
 
@@ -1691,11 +1668,9 @@ mod test {
             .extract_policy(&signers_container, build_sat_expired, &secp)
             .unwrap()
             .unwrap();
-        assert!(
-            matches!(&policy_expired.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &3
+        assert_matches!(&policy_expired.satisfaction, Satisfaction::Partial { n, m, items, .. } if n == &3
              && m == &2
              && items == &vec![0]
-            )
         );
         //println!("{}", serde_json::to_string(&policy_expired).unwrap());
 
@@ -1711,11 +1686,9 @@ mod test {
             .extract_policy(&signers_container, build_sat_expired_signed, &secp)
             .unwrap()
             .unwrap();
-        assert!(
-            matches!(&policy_expired_signed.satisfaction, Satisfaction::PartialComplete { n, m, items, .. } if n == &3
+        assert_matches!(&policy_expired_signed.satisfaction, Satisfaction::PartialComplete { n, m, items, .. } if n == &3
              && m == &2
              && items == &vec![0, 1]
-            )
         );
         //println!("{}", serde_json::to_string(&policy_expired_signed).unwrap());
     }
@@ -1790,12 +1763,8 @@ mod test {
             .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])
-        );
+        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));
@@ -1887,19 +1856,11 @@ mod test {
             .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_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])
-        );
+        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,

src/descriptor/template.rs

@@ -235,14 +235,17 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
 /// )?;
 ///
 /// 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");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "pkh([c55b303f/44'/1'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)#cfhumdqz");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 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)
+        P2Pkh(legacy::make_bipxx_public(
+            44, self.0, self.1, self.2, network,
+        )?)
+        .build(network)
     }
 }
 
@@ -284,7 +287,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
 
 /// BIP49 public template. Expands to `sh(wpkh(key/{0,1}/*))`
 ///
-/// This assumes that the key used has already been derived with `m/49'/0'/0'`.
+/// This assumes that the key used has already been derived with `m/49'/0'/0'` for Mainnet or `m/49'/1'/0'` for Testnet.
 ///
 /// This template requires the parent fingerprint to populate correctly the metadata of PSBTs.
 ///
@@ -311,14 +314,17 @@ 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'/1'/0']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))#3tka9g0q");
 /// # 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)
+        P2Wpkh_P2Sh(segwit_v0::make_bipxx_public(
+            49, self.0, self.1, self.2, network,
+        )?)
+        .build(network)
     }
 }
 
@@ -360,7 +366,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 
 /// BIP84 public template. Expands to `wpkh(key/{0,1}/*)`
 ///
-/// This assumes that the key used has already been derived with `m/84'/0'/0'`.
+/// This assumes that the key used has already been derived with `m/84'/0'/0'` for Mainnet or `m/84'/1'/0'` for Testnet.
 ///
 /// This template requires the parent fingerprint to populate correctly the metadata of PSBTs.
 ///
@@ -387,14 +393,17 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 /// )?;
 ///
 /// 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");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "wpkh([c55b303f/84'/1'/0']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)#dhu402yv");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
 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)
+        P2Wpkh(segwit_v0::make_bipxx_public(
+            84, self.0, self.1, self.2, network,
+        )?)
+        .build(network)
     }
 }
 
@@ -440,6 +449,7 @@ macro_rules! expand_make_bipxx {
                 key: K,
                 parent_fingerprint: bip32::Fingerprint,
                 keychain: KeychainKind,
+                network: Network,
             ) -> Result<impl IntoDescriptorKey<$ctx>, DescriptorError> {
                 let derivation_path: bip32::DerivationPath = match keychain {
                     KeychainKind::External => vec![bip32::ChildNumber::from_normal_idx(0)?].into(),
@@ -448,7 +458,10 @@ macro_rules! expand_make_bipxx {
 
                 let source_path = bip32::DerivationPath::from(vec![
                     bip32::ChildNumber::from_hardened_idx(bip)?,
-                    bip32::ChildNumber::from_hardened_idx(0)?,
+                    match network {
+                        Network::Bitcoin => bip32::ChildNumber::from_hardened_idx(0)?,
+                        _ => bip32::ChildNumber::from_hardened_idx(1)?,
+                    },
                     bip32::ChildNumber::from_hardened_idx(0)?,
                 ]);
 
@@ -470,6 +483,7 @@ mod test {
     use super::*;
     use crate::descriptor::{DescriptorError, DescriptorMeta};
     use crate::keys::ValidNetworks;
+    use assert_matches::assert_matches;
     use bitcoin::network::constants::Network::Regtest;
     use miniscript::descriptor::{DescriptorPublicKey, KeyMap};
     use miniscript::Descriptor;
@@ -488,9 +502,9 @@ mod test {
         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 }));
+            assert_matches!(purpose, Hardened { index: 44 });
             let coin_type = path.get(1).unwrap();
-            assert!(matches!(coin_type, Hardened { index: 0 }));
+            assert_matches!(coin_type, Hardened { index: 0 });
         }
 
         let tprvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
@@ -502,9 +516,9 @@ mod test {
         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 }));
+            assert_matches!(purpose, Hardened { index: 44 });
             let coin_type = path.get(1).unwrap();
-            assert!(matches!(coin_type, Hardened { index: 1 }));
+            assert_matches!(coin_type, Hardened { index: 1 });
         }
     }
 

src/error.rs

@@ -107,7 +107,7 @@ pub enum Error {
     MiniscriptPsbt(MiniscriptPsbtError),
     /// BIP32 error
     Bip32(bitcoin::util::bip32::Error),
-    /// An ECDSA error
+    /// A secp256k1 error
     Secp256k1(bitcoin::secp256k1::Error),
     /// Error serializing or deserializing JSON data
     Json(serde_json::Error),
@@ -157,6 +157,18 @@ pub enum MiniscriptPsbtError {
     OutputUpdate(miniscript::psbt::OutputUpdateError),
 }
 
+impl fmt::Display for MiniscriptPsbtError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Conversion(err) => write!(f, "Conversion error: {}", err),
+            Self::UtxoUpdate(err) => write!(f, "UTXO update error: {}", err),
+            Self::OutputUpdate(err) => write!(f, "Output update error: {}", err),
+        }
+    }
+}
+
+impl std::error::Error for MiniscriptPsbtError {}
+
 /// Represents the last failed [`crate::blockchain::WalletSync`] sync attempt in which we were short
 /// on cached `scriptPubKey`s.
 #[derive(Debug)]
@@ -169,7 +181,93 @@ pub struct MissingCachedScripts {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::InvalidU32Bytes(_) => write!(
+                f,
+                "Wrong number of bytes found when trying to convert to u32"
+            ),
+            Self::Generic(err) => write!(f, "Generic error: {}", err),
+            Self::ScriptDoesntHaveAddressForm => write!(f, "Script doesn't have address form"),
+            Self::NoRecipients => write!(f, "Cannot build tx without recipients"),
+            Self::NoUtxosSelected => write!(f, "No UTXO selected"),
+            Self::OutputBelowDustLimit(limit) => {
+                write!(f, "Output below the dust limit: {}", limit)
+            }
+            Self::InsufficientFunds { needed, available } => write!(
+                f,
+                "Insufficient funds: {} sat available of {} sat needed",
+                available, needed
+            ),
+            Self::BnBTotalTriesExceeded => {
+                write!(f, "Branch and bound coin selection: total tries exceeded")
+            }
+            Self::BnBNoExactMatch => write!(f, "Branch and bound coin selection: not exact match"),
+            Self::UnknownUtxo => write!(f, "UTXO not found in the internal database"),
+            Self::TransactionNotFound => {
+                write!(f, "Transaction not found in the internal database")
+            }
+            Self::TransactionConfirmed => write!(f, "Transaction already confirmed"),
+            Self::IrreplaceableTransaction => write!(f, "Transaction can't be replaced"),
+            Self::FeeRateTooLow { required } => write!(
+                f,
+                "Fee rate too low: required {} sat/vbyte",
+                required.as_sat_per_vb()
+            ),
+            Self::FeeTooLow { required } => write!(f, "Fee to low: required {} sat", required),
+            Self::FeeRateUnavailable => write!(f, "Fee rate unavailable"),
+            Self::MissingKeyOrigin(err) => write!(f, "Missing key origin: {}", err),
+            Self::Key(err) => write!(f, "Key error: {}", err),
+            Self::ChecksumMismatch => write!(f, "Descriptor checksum mismatch"),
+            Self::SpendingPolicyRequired(keychain_kind) => {
+                write!(f, "Spending policy required: {:?}", keychain_kind)
+            }
+            Self::InvalidPolicyPathError(err) => write!(f, "Invalid policy path: {}", err),
+            Self::Signer(err) => write!(f, "Signer error: {}", err),
+            Self::InvalidNetwork { requested, found } => write!(
+                f,
+                "Invalid network: requested {} but found {}",
+                requested, found
+            ),
+            #[cfg(feature = "verify")]
+            Self::Verification(err) => write!(f, "Transaction verification error: {}", err),
+            Self::InvalidProgressValue(progress) => {
+                write!(f, "Invalid progress value: {}", progress)
+            }
+            Self::ProgressUpdateError => write!(
+                f,
+                "Progress update error (maybe the channel has been closed)"
+            ),
+            Self::InvalidOutpoint(outpoint) => write!(
+                f,
+                "Requested outpoint doesn't exist in the tx: {}",
+                outpoint
+            ),
+            Self::Descriptor(err) => write!(f, "Descriptor error: {}", err),
+            Self::Encode(err) => write!(f, "Encoding error: {}", err),
+            Self::Miniscript(err) => write!(f, "Miniscript error: {}", err),
+            Self::MiniscriptPsbt(err) => write!(f, "Miniscript PSBT error: {}", err),
+            Self::Bip32(err) => write!(f, "BIP32 error: {}", err),
+            Self::Secp256k1(err) => write!(f, "Secp256k1 error: {}", err),
+            Self::Json(err) => write!(f, "Serialize/Deserialize JSON error: {}", err),
+            Self::Hex(err) => write!(f, "Hex decoding error: {}", err),
+            Self::Psbt(err) => write!(f, "PSBT error: {}", err),
+            Self::PsbtParse(err) => write!(f, "Impossible to parse PSBT: {}", err),
+            Self::MissingCachedScripts(missing_cached_scripts) => {
+                write!(f, "Missing cached scripts: {:?}", missing_cached_scripts)
+            }
+            #[cfg(feature = "electrum")]
+            Self::Electrum(err) => write!(f, "Electrum client error: {}", err),
+            #[cfg(feature = "esplora")]
+            Self::Esplora(err) => write!(f, "Esplora client error: {}", err),
+            #[cfg(feature = "compact_filters")]
+            Self::CompactFilters(err) => write!(f, "Compact filters client error: {}", err),
+            #[cfg(feature = "key-value-db")]
+            Self::Sled(err) => write!(f, "Sled database error: {}", err),
+            #[cfg(feature = "rpc")]
+            Self::Rpc(err) => write!(f, "RPC client error: {}", err),
+            #[cfg(feature = "sqlite")]
+            Self::Rusqlite(err) => write!(f, "SQLite error: {}", err),
+        }
     }
 }
 

src/keys/mod.rs

@@ -40,7 +40,7 @@ pub mod bip39;
 /// Set of valid networks for a key
 pub type ValidNetworks = HashSet<Network>;
 
-/// Create a set containing mainnet, testnet and regtest
+/// Create a set containing mainnet, testnet, signet, and regtest
 pub fn any_network() -> ValidNetworks {
     vec![
         Network::Bitcoin,
@@ -95,7 +95,7 @@ impl<Ctx: ScriptContext> DescriptorKey<Ctx> {
     }
 
     // This method is used internally by `bdk::fragment!` and `bdk::descriptor!`. It has to be
-    // public because it is effectively called by external crates, once the macros are expanded,
+    // public because it is effectively called by external crates once the macros are expanded,
     // but since it is not meant to be part of the public api we hide it from the docs.
     #[doc(hidden)]
     pub fn extract(
@@ -375,7 +375,7 @@ impl<Ctx: ScriptContext> From<bip32::ExtendedPrivKey> for ExtendedKey<Ctx> {
 /// `(DerivableKey, KeySource, DerivationPath)` tuples.
 ///
 /// For key types that don't encode any indication about the path to use (like bip39), it's
-/// generally recommended to implemented this trait instead of [`IntoDescriptorKey`]. The same
+/// generally recommended to implement this trait instead of [`IntoDescriptorKey`]. The same
 /// rules regarding script context and valid networks apply.
 ///
 /// ## Examples
@@ -935,7 +935,14 @@ impl_error!(bitcoin::util::bip32::Error, Bip32, KeyError);
 
 impl std::fmt::Display for KeyError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::InvalidScriptContext => write!(f, "Invalid script context"),
+            Self::InvalidNetwork => write!(f, "Invalid network"),
+            Self::InvalidChecksum => write!(f, "Invalid checksum"),
+            Self::Message(err) => write!(f, "{}", err),
+            Self::Bip32(err) => write!(f, "BIP32 error: {}", err),
+            Self::Miniscript(err) => write!(f, "Miniscript error: {}", err),
+        }
     }
 }
 

src/lib.rs

@@ -227,7 +227,7 @@ compile_error!(
 #[cfg(feature = "keys-bip39")]
 extern crate bip39;
 
-#[cfg(any(target_arch = "wasm32", feature = "async-interface"))]
+#[cfg(feature = "async-interface")]
 #[macro_use]
 extern crate async_trait;
 #[macro_use]
@@ -256,6 +256,9 @@ pub extern crate rusqlite;
 #[macro_use]
 pub mod testutils;
 
+#[cfg(test)]
+extern crate assert_matches;
+
 #[allow(unused_imports)]
 #[macro_use]
 pub(crate) mod error;

src/psbt/mod.rs

@@ -22,7 +22,7 @@ pub trait PsbtUtils {
     /// Get the `TxOut` for the specified input index, if it doesn't exist in the PSBT `None` is returned.
     fn get_utxo_for(&self, input_index: usize) -> Option<TxOut>;
 
-    /// The total transaction fee amount, sum of input amounts minus sum of output amounts, in Sats.
+    /// The total transaction fee amount, sum of input amounts minus sum of output amounts, in sats.
     /// If the PSBT is missing a TxOut for an input returns None.
     fn fee_amount(&self) -> Option<u64>;
 

src/testutils/configurable_blockchain_tests.rs

@@ -23,7 +23,7 @@ pub trait ConfigurableBlockchainTester<B: ConfigurableBlockchain>: Sized {
         None
     }
 
-    /// Runs all avaliable tests.
+    /// Runs all available tests.
     fn run(&self) {
         let test_client = &mut TestClient::default();
 

src/types.rs

@@ -230,7 +230,6 @@ pub struct TransactionDetails {
     pub transaction: Option<Transaction>,
     /// Transaction id
     pub txid: Txid,
-
     /// Received value (sats)
     /// Sum of owned outputs of this transaction.
     pub received: u64,
@@ -242,11 +241,25 @@ pub struct TransactionDetails {
     /// Server backend, but it could be `None` with a Bitcoin RPC node without txindex that receive
     /// funds while offline.
     pub fee: Option<u64>,
-    /// If the transaction is confirmed, contains height and timestamp of the block containing the
+    /// If the transaction is confirmed, contains height and Unix timestamp of the block containing the
     /// transaction, unconfirmed transaction contains `None`.
     pub confirmation_time: Option<BlockTime>,
 }
 
+impl PartialOrd for TransactionDetails {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for TransactionDetails {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.confirmation_time
+            .cmp(&other.confirmation_time)
+            .then_with(|| self.txid.cmp(&other.txid))
+    }
+}
+
 /// Block height and timestamp of a block
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
 pub struct BlockTime {
@@ -256,6 +269,20 @@ pub struct BlockTime {
     pub timestamp: u64,
 }
 
+impl PartialOrd for BlockTime {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for BlockTime {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.height
+            .cmp(&other.height)
+            .then_with(|| self.timestamp.cmp(&other.timestamp))
+    }
+}
+
 /// **DEPRECATED**: Confirmation time of a transaction
 ///
 /// The structure has been renamed to `BlockTime`
@@ -334,6 +361,95 @@ impl std::iter::Sum for Balance {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use bitcoin::hashes::Hash;
+
+    #[test]
+    fn sort_block_time() {
+        let block_time_a = BlockTime {
+            height: 100,
+            timestamp: 100,
+        };
+
+        let block_time_b = BlockTime {
+            height: 100,
+            timestamp: 110,
+        };
+
+        let block_time_c = BlockTime {
+            height: 0,
+            timestamp: 0,
+        };
+
+        let mut vec = vec![
+            block_time_a.clone(),
+            block_time_b.clone(),
+            block_time_c.clone(),
+        ];
+        vec.sort();
+        let expected = vec![block_time_c, block_time_a, block_time_b];
+
+        assert_eq!(vec, expected)
+    }
+
+    #[test]
+    fn sort_tx_details() {
+        let block_time_a = BlockTime {
+            height: 100,
+            timestamp: 100,
+        };
+
+        let block_time_b = BlockTime {
+            height: 0,
+            timestamp: 0,
+        };
+
+        let tx_details_a = TransactionDetails {
+            transaction: None,
+            txid: Txid::from_inner([0; 32]),
+            received: 0,
+            sent: 0,
+            fee: None,
+            confirmation_time: None,
+        };
+
+        let tx_details_b = TransactionDetails {
+            transaction: None,
+            txid: Txid::from_inner([0; 32]),
+            received: 0,
+            sent: 0,
+            fee: None,
+            confirmation_time: Some(block_time_a),
+        };
+
+        let tx_details_c = TransactionDetails {
+            transaction: None,
+            txid: Txid::from_inner([0; 32]),
+            received: 0,
+            sent: 0,
+            fee: None,
+            confirmation_time: Some(block_time_b.clone()),
+        };
+
+        let tx_details_d = TransactionDetails {
+            transaction: None,
+            txid: Txid::from_inner([1; 32]),
+            received: 0,
+            sent: 0,
+            fee: None,
+            confirmation_time: Some(block_time_b),
+        };
+
+        let mut vec = vec![
+            tx_details_a.clone(),
+            tx_details_b.clone(),
+            tx_details_c.clone(),
+            tx_details_d.clone(),
+        ];
+        vec.sort();
+        let expected = vec![tx_details_a, tx_details_c, tx_details_d, tx_details_b];
+
+        assert_eq!(vec, expected)
+    }
 
     #[test]
     fn can_store_feerate_in_const() {

src/wallet/coin_selection.rs

@@ -102,11 +102,11 @@ use crate::{error::Error, Utxo};
 use bitcoin::consensus::encode::serialize;
 use bitcoin::Script;
 
+#[cfg(test)]
+use assert_matches::assert_matches;
 use rand::seq::SliceRandom;
 #[cfg(not(test))]
 use rand::thread_rng;
-#[cfg(test)]
-use rand::{rngs::StdRng, SeedableRng};
 use std::collections::HashMap;
 use std::convert::TryInto;
 
@@ -671,6 +671,7 @@ impl BranchAndBoundCoinSelection {
         optional_utxos.shuffle(&mut thread_rng());
         #[cfg(test)]
         {
+            use rand::{rngs::StdRng, SeedableRng};
             let seed = [0; 32];
             let mut rng: StdRng = SeedableRng::from_seed(seed);
             optional_utxos.shuffle(&mut rng);
@@ -1522,24 +1523,22 @@ mod test {
         let database = MemoryDatabase::default();
         let drain_script = Script::default();
 
-        let err = BranchAndBoundCoinSelection::default()
-            .coin_select(
-                &database,
-                vec![],
-                utxos,
-                FeeRate::from_sat_per_vb(10.0),
-                500_000,
-                &drain_script,
-            )
-            .unwrap_err();
+        let selection = BranchAndBoundCoinSelection::default().coin_select(
+            &database,
+            vec![],
+            utxos,
+            FeeRate::from_sat_per_vb(10.0),
+            500_000,
+            &drain_script,
+        );
 
-        assert!(matches!(
-            err,
-            Error::InsufficientFunds {
+        assert_matches!(
+            selection,
+            Err(Error::InsufficientFunds {
                 available: 300_000,
                 ..
-            }
-        ));
+            })
+        );
     }
 
     #[test]
@@ -1552,24 +1551,22 @@ mod test {
             .into_iter()
             .partition(|u| matches!(u, WeightedUtxo { utxo, .. } if utxo.txout().value < 1000));
 
-        let err = BranchAndBoundCoinSelection::default()
-            .coin_select(
-                &database,
-                required,
-                optional,
-                FeeRate::from_sat_per_vb(10.0),
-                500_000,
-                &drain_script,
-            )
-            .unwrap_err();
+        let selection = BranchAndBoundCoinSelection::default().coin_select(
+            &database,
+            required,
+            optional,
+            FeeRate::from_sat_per_vb(10.0),
+            500_000,
+            &drain_script,
+        );
 
-        assert!(matches!(
-            err,
-            Error::InsufficientFunds {
+        assert_matches!(
+            selection,
+            Err(Error::InsufficientFunds {
                 available: 300_010,
                 ..
-            }
-        ));
+            })
+        );
     }
 
     #[test]
@@ -1578,23 +1575,21 @@ mod test {
         let database = MemoryDatabase::default();
         let drain_script = Script::default();
 
-        let err = BranchAndBoundCoinSelection::default()
-            .coin_select(
-                &database,
-                utxos,
-                vec![],
-                FeeRate::from_sat_per_vb(10_000.0),
-                500_000,
-                &drain_script,
-            )
-            .unwrap_err();
+        let selection = BranchAndBoundCoinSelection::default().coin_select(
+            &database,
+            utxos,
+            vec![],
+            FeeRate::from_sat_per_vb(10_000.0),
+            500_000,
+            &drain_script,
+        );
 
-        assert!(matches!(
-            err,
-            Error::InsufficientFunds {
+        assert_matches!(
+            selection,
+            Err(Error::InsufficientFunds {
                 available: 300_010,
                 ..
-            }
-        ));
+            })
+        );
     }
 }

src/wallet/export.rs

@@ -134,15 +134,11 @@ impl FullyNodedExport {
         let blockheight = match wallet.database.borrow().iter_txs(false) {
             _ if !include_blockheight => 0,
             Err(_) => 0,
-            Ok(txs) => {
-                let mut heights = txs
-                    .into_iter()
-                    .map(|tx| tx.confirmation_time.map(|c| c.height).unwrap_or(0))
-                    .collect::<Vec<_>>();
-                heights.sort_unstable();
-
-                *heights.last().unwrap_or(&0)
-            }
+            Ok(txs) => txs
+                .into_iter()
+                .filter_map(|tx| tx.confirmation_time.map(|c| c.height))
+                .min()
+                .unwrap_or(0),
         };
 
         let export = FullyNodedExport {
@@ -249,6 +245,22 @@ mod test {
             fee: Some(500),
             confirmation_time: Some(BlockTime {
                 timestamp: 12345678,
+                height: 5001,
+            }),
+        })
+        .unwrap();
+
+        db.set_tx(&TransactionDetails {
+            transaction: None,
+            txid: Txid::from_str(
+                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            )
+            .unwrap(),
+            received: 25_000,
+            sent: 0,
+            fee: Some(300),
+            confirmation_time: Some(BlockTime {
+                timestamp: 12345677,
                 height: 5000,
             }),
         })

src/wallet/hardwaresigner.rs

@@ -24,9 +24,12 @@
 //! # use std::sync::Arc;
 //! #
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! let devices = HWIClient::enumerate()?;
-//! let first_device = devices.first().expect("No devices found!");
-//! let custom_signer = HWISigner::from_device(first_device, HWIChain::Test)?;
+//! let mut devices = HWIClient::enumerate()?;
+//! if devices.is_empty() {
+//!     panic!("No devices found!");
+//! }
+//! let first_device = devices.remove(0)?;
+//! let custom_signer = HWISigner::from_device(&first_device, HWIChain::Test)?;
 //!
 //! # let mut wallet = Wallet::new(
 //! #     "",

src/wallet/mod.rs

@@ -17,7 +17,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::collections::{BTreeMap, HashSet};
 use std::fmt;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -132,7 +132,7 @@ pub enum AddressIndex {
     Reset(u32),
 }
 
-/// A derived address and the index it was found at
+/// A derived address and the index it was found at.
 /// For convenience this automatically derefs to `Address`
 #[derive(Debug, PartialEq, Eq)]
 pub struct AddressInfo {
@@ -1084,7 +1084,7 @@ where
     }
 
     /// Sign a transaction with all the wallet's signers, in the order specified by every signer's
-    /// [`SignerOrdering`]
+    /// [`SignerOrdering`]. This function returns the `Result` type with an encapsulated `bool` that has the value true if the PSBT was finalized, or false otherwise.
     ///
     /// The [`SignOptions`] can be used to tweak the behavior of the software signers, and the way
     /// the transaction is finalized at the end. Note that it can't be guaranteed that *every*
@@ -1719,14 +1719,11 @@ where
         let max_rounds = if has_wildcard { 100 } else { 1 };
 
         for _ in 0..max_rounds {
-            let sync_res =
-                if run_setup {
-                    maybe_await!(blockchain
-                        .wallet_setup(self.database.borrow_mut().deref_mut(), new_progress()))
-                } else {
-                    maybe_await!(blockchain
-                        .wallet_sync(self.database.borrow_mut().deref_mut(), new_progress()))
-                };
+            let sync_res = if run_setup {
+                maybe_await!(blockchain.wallet_setup(&self.database, new_progress()))
+            } else {
+                maybe_await!(blockchain.wallet_sync(&self.database, new_progress()))
+            };
 
             // If the error is the special `MissingCachedScripts` error, we return the number of
             // scripts we should ensure cached.
@@ -1851,6 +1848,7 @@ pub fn get_funded_wallet(
 
 #[cfg(test)]
 pub(crate) mod test {
+    use assert_matches::assert_matches;
     use bitcoin::{util::psbt, Network, PackedLockTime, Sequence};
 
     use crate::database::Database;
@@ -4425,11 +4423,9 @@ pub(crate) mod test {
             result.is_err(),
             "Signing should have failed because the TX uses non-standard sighashes"
         );
-        assert!(
-            matches!(
-                result.unwrap_err(),
-                Error::Signer(SignerError::NonStandardSighash)
-            ),
+        assert_matches!(
+            result,
+            Err(Error::Signer(SignerError::NonStandardSighash)),
             "Signing failed with the wrong error type"
         );
 
@@ -4912,16 +4908,10 @@ pub(crate) mod test {
                 ..Default::default()
             },
         );
-        assert!(
-            result.is_err(),
-            "Signing should have failed because the witness_utxo is missing"
-        );
-        assert!(
-            matches!(
-                result.unwrap_err(),
-                Error::Signer(SignerError::MissingWitnessUtxo)
-            ),
-            "Signing failed with the wrong error type"
+        assert_matches!(
+            result,
+            Err(Error::Signer(SignerError::MissingWitnessUtxo)),
+            "Signing should have failed with the correct error because the witness_utxo is missing"
         );
 
         // restore the witness_utxo
@@ -4935,9 +4925,9 @@ pub(crate) mod test {
             },
         );
 
-        assert!(result.is_ok(), "Signing should have worked");
-        assert!(
-            result.unwrap(),
+        assert_matches!(
+            result,
+            Ok(true),
             "Should finalize the input since we can produce signatures"
         );
     }
@@ -5262,11 +5252,9 @@ pub(crate) mod test {
             result.is_err(),
             "Signing should have failed because the TX uses non-standard sighashes"
         );
-        assert!(
-            matches!(
-                result.unwrap_err(),
-                Error::Signer(SignerError::NonStandardSighash)
-            ),
+        assert_matches!(
+            result,
+            Err(Error::Signer(SignerError::NonStandardSighash)),
             "Signing failed with the wrong error type"
         );
 
@@ -5282,11 +5270,9 @@ pub(crate) mod test {
             result.is_err(),
             "Signing should have failed because the witness_utxo is missing"
         );
-        assert!(
-            matches!(
-                result.unwrap_err(),
-                Error::Signer(SignerError::MissingWitnessUtxo)
-            ),
+        assert_matches!(
+            result,
+            Err(Error::Signer(SignerError::MissingWitnessUtxo)),
             "Signing failed with the wrong error type"
         );
 
@@ -5367,26 +5353,26 @@ pub(crate) mod test {
         builder
             .add_recipient(addr.script_pubkey(), balance.immature / 2)
             .current_height(confirmation_time);
-        assert!(matches!(
-            builder.finish().unwrap_err(),
-            Error::InsufficientFunds {
+        assert_matches!(
+            builder.finish(),
+            Err(Error::InsufficientFunds {
                 needed: _,
                 available: 0
-            }
-        ));
+            })
+        );
 
         // Still unspendable...
         let mut builder = wallet.build_tx();
         builder
             .add_recipient(addr.script_pubkey(), balance.immature / 2)
             .current_height(not_yet_mature_time);
-        assert!(matches!(
-            builder.finish().unwrap_err(),
-            Error::InsufficientFunds {
+        assert_matches!(
+            builder.finish(),
+            Err(Error::InsufficientFunds {
                 needed: _,
                 available: 0
-            }
-        ));
+            })
+        );
 
         // ...Now the coinbase is mature :)
         let sync_time = SyncTime {
@@ -5428,10 +5414,7 @@ pub(crate) mod test {
 
         builder.add_recipient(addr.script_pubkey(), 0);
 
-        assert!(matches!(
-            builder.finish().unwrap_err(),
-            Error::OutputBelowDustLimit(0)
-        ));
+        assert_matches!(builder.finish(), Err(Error::OutputBelowDustLimit(0)));
 
         let mut builder = wallet.build_tx();
 
@@ -5546,11 +5529,14 @@ pub(crate) mod test {
         use hwi::types::HWIChain;
         use hwi::HWIClient;
 
-        let devices = HWIClient::enumerate().unwrap();
-        let device = devices.first().expect("No devices found");
-        let client = HWIClient::get_client(device, true, HWIChain::Regtest).unwrap();
-        let descriptors = client.get_descriptors(None).unwrap();
-        let custom_signer = HWISigner::from_device(device, HWIChain::Regtest).unwrap();
+        let mut devices = HWIClient::enumerate().unwrap();
+        if devices.is_empty() {
+            panic!("No devices found!");
+        }
+        let device = devices.remove(0).unwrap();
+        let client = HWIClient::get_client(&device, true, HWIChain::Regtest).unwrap();
+        let descriptors = client.get_descriptors::<String>(None).unwrap();
+        let custom_signer = HWISigner::from_device(&device, HWIChain::Regtest).unwrap();
 
         let (mut wallet, _, _) = get_funded_wallet(&descriptors.internal[0]);
         wallet.add_signer(

src/wallet/signer.rs

@@ -180,7 +180,22 @@ impl From<sighash::Error> for SignerError {
 
 impl fmt::Display for SignerError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::MissingKey => write!(f, "Missing private key"),
+            Self::InvalidKey => write!(f, "The private key in use has the right fingerprint but derives differently than expected"),
+            Self::UserCanceled => write!(f, "The user canceled the operation"),
+            Self::InputIndexOutOfRange => write!(f, "Input index out of range"),
+            Self::MissingNonWitnessUtxo => write!(f, "Missing non-witness UTXO"),
+            Self::InvalidNonWitnessUtxo => write!(f, "Invalid non-witness UTXO"),
+            Self::MissingWitnessUtxo => write!(f, "Missing witness UTXO"),
+            Self::MissingWitnessScript => write!(f, "Missing witness script"),
+            Self::MissingHdKeypath => write!(f, "Missing fingerprint and derivation path"),
+            Self::NonStandardSighash => write!(f, "The psbt contains a non standard sighash"),
+            Self::InvalidSighash => write!(f, "Invalid SIGHASH for the signing context in use"),
+            Self::SighashError(err) => write!(f, "Error while computing the hash to sign: {}", err),
+            #[cfg(feature = "hardware-signer")]
+            Self::HWIError(err) => write!(f, "Error while signing using hardware wallets: {}", err),
+        }
     }
 }
 
@@ -998,6 +1013,7 @@ mod signers_container_tests {
     use crate::descriptor;
     use crate::descriptor::IntoWalletDescriptor;
     use crate::keys::{DescriptorKey, IntoDescriptorKey};
+    use assert_matches::assert_matches;
     use bitcoin::secp256k1::{All, Secp256k1};
     use bitcoin::util::bip32;
     use bitcoin::Network;
@@ -1067,17 +1083,17 @@ mod signers_container_tests {
         signers.add_external(id2.clone(), SignerOrdering(2), signer2.clone());
         signers.add_external(id3.clone(), SignerOrdering(3), signer3.clone());
 
-        assert!(matches!(signers.find(id1), Some(signer) if is_equal(signer, &signer1)));
-        assert!(matches!(signers.find(id2), Some(signer) if is_equal(signer, &signer2)));
-        assert!(matches!(signers.find(id3.clone()), Some(signer) if is_equal(signer, &signer3)));
+        assert_matches!(signers.find(id1), Some(signer) if is_equal(signer, &signer1));
+        assert_matches!(signers.find(id2), Some(signer) if is_equal(signer, &signer2));
+        assert_matches!(signers.find(id3.clone()), Some(signer) if is_equal(signer, &signer3));
 
         // The `signer4` has the same ID as `signer3` but lower ordering.
         // It should be found by `id3` instead of `signer3`.
         signers.add_external(id3.clone(), SignerOrdering(2), signer4.clone());
-        assert!(matches!(signers.find(id3), Some(signer) if is_equal(signer, &signer4)));
+        assert_matches!(signers.find(id3), Some(signer) if is_equal(signer, &signer4));
 
         // Can't find anything with ID that doesn't exist
-        assert!(matches!(signers.find(id_nonexistent), None));
+        assert_matches!(signers.find(id_nonexistent), None);
     }
 
     #[derive(Debug, Clone, Copy)]

src/wallet/verify.rs

@@ -91,7 +91,12 @@ pub enum VerifyError {
 
 impl fmt::Display for VerifyError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        match self {
+            Self::MissingInputTx(txid) => write!(f, "The transaction being spent is not available in the database or the blockchain client: {}", txid),
+            Self::InvalidInput(outpoint) => write!(f, "The transaction being spent doesn't have the requested output: {}", outpoint),
+            Self::Consensus(err) => write!(f, "Consensus error: {:?}", err),
+            Self::Global(err) => write!(f, "Generic error: {}", err),
+        }
     }
 }
 
@@ -108,6 +113,7 @@ impl_error!(bitcoinconsensus::Error, Consensus, VerifyError);
 mod test {
     use super::*;
     use crate::database::{BatchOperations, MemoryDatabase};
+    use assert_matches::assert_matches;
     use bitcoin::consensus::encode::deserialize;
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::{Transaction, Txid};
@@ -137,9 +143,7 @@ mod test {
         }
 
         let result = verify_tx(&signed_tx, &database, &blockchain);
-        assert!(result.is_err(), "Should fail with missing input tx");
-        assert!(
-            matches!(result, Err(VerifyError::MissingInputTx(txid)) if txid == prev_tx.txid()),
+        assert_matches!(result, Err(VerifyError::MissingInputTx(txid)) if txid == prev_tx.txid(),
             "Error should be a `MissingInputTx` error"
         );
 
@@ -147,9 +151,9 @@ mod test {
         database.set_raw_tx(&prev_tx).unwrap();
 
         let result = verify_tx(&unsigned_tx, &database, &blockchain);
-        assert!(result.is_err(), "Should fail since the TX is unsigned");
-        assert!(
-            matches!(result, Err(VerifyError::Consensus(_))),
+        assert_matches!(
+            result,
+            Err(VerifyError::Consensus(_)),
             "Error should be a `Consensus` error"
         );