build(deps): bump actions/setup-python from 4 to 5

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 4 to 5. - [Release notes](https://github.com/actions/setup-python/releases) - [Commits](https://github.com/actions/setup-python/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/setup-python dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>
2023-12-11 06:05:08 +00:00
92 changed files with 2772 additions and 5324 deletions
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -33,7 +33,7 @@ jobs:
      - name: Run simulator image
        run: docker run --name simulator --network=host hwi/ledger_emulator &
      - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: '3.9'
      - name: Install python dependencies
--- a/.github/workflows/cont_integration.yml
+++ b/.github/workflows/cont_integration.yml
@@ -12,7 +12,7 @@ jobs:
        rust:
          - version: stable
            clippy: true
-          - version: 1.63.0 # MSRV
+          - version: 1.57.0 # MSRV
        features:
          - --no-default-features
          - --all-features
@@ -28,12 +28,28 @@ jobs:
      - name: Rust Cache
        uses: Swatinem/rust-cache@v2.2.1
      - name: Pin dependencies for MSRV
-        if: matrix.rust.version == '1.63.0'
+        if: matrix.rust.version == '1.57.0'
        run: |
-          cargo update -p zstd-sys --precise "2.0.8+zstd.1.5.5"
-          cargo update -p time --precise "0.3.20"
-          cargo update -p home --precise "0.5.5"
-          cargo update -p proptest --precise "1.2.0"
+          cargo update -p log --precise "0.4.18"
+          cargo update -p tempfile --precise "3.6.0"
+          cargo update -p reqwest --precise "0.11.18"
+          cargo update -p hyper-rustls --precise 0.24.0
+          cargo update -p rustls:0.21.9 --precise "0.21.1"
+          cargo update -p rustls:0.20.9 --precise "0.20.8"
+          cargo update -p tokio --precise "1.29.1"
+          cargo update -p tokio-util --precise "0.7.8"
+          cargo update -p flate2 --precise "1.0.26"
+          cargo update -p h2 --precise "0.3.20"
+          cargo update -p rustls-webpki:0.100.3 --precise "0.100.1"
+          cargo update -p rustls-webpki:0.101.7 --precise "0.101.1"
+          cargo update -p zip --precise "0.6.2"
+          cargo update -p time --precise "0.3.13"
+          cargo update -p byteorder --precise "1.4.3"
+          cargo update -p webpki --precise "0.22.2"
+          cargo update -p os_str_bytes --precise 6.5.1
+          cargo update -p sct --precise 0.7.0
+          cargo update -p cc --precise "1.0.81"
+          cargo update -p jobserver --precise "0.1.26"
      - name: Build
        run: cargo build ${{ matrix.features }}
      - name: Test
@@ -118,7 +134,9 @@ jobs:
      - uses: actions/checkout@v1
      - uses: actions-rs/toolchain@v1
        with:
-            toolchain: stable
+            # we pin clippy instead of using "stable" so that our CI doesn't break
+            # at each new cargo release
+            toolchain: "1.67.0"
            components: clippy
            override: true
      - name: Rust Cache
--- a/.github/workflows/nightly_docs.yml
+++ b/.github/workflows/nightly_docs.yml
@@ -17,8 +17,6 @@ jobs:
        run: rustup update
      - name: Rust Cache
        uses: Swatinem/rust-cache@v2.2.1
-      - name: Pin dependencies for MSRV
-        run: cargo update -p home --precise "0.5.5"
      - name: Build docs
        run: cargo doc --no-deps
        env:
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,8 +7,6 @@ members = [
    "crates/electrum",
    "crates/esplora",
    "crates/bitcoind_rpc",
-    "crates/hwi",
-    "crates/testenv",
    "example-crates/example_cli",
    "example-crates/example_electrum",
    "example-crates/example_esplora",
@@ -16,7 +14,6 @@ members = [
    "example-crates/wallet_electrum",
    "example-crates/wallet_esplora_blocking",
    "example-crates/wallet_esplora_async",
-    "example-crates/wallet_rpc",
    "nursery/tmp_plan",
    "nursery/coin_select"
 ]
--- a/README.md
+++ b/README.md
@@ -15,7 +15,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/2022/08/11/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%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>

@@ -48,8 +48,6 @@ The project is split up into several crates in the `/crates` directory:
 Fully working examples of how to use these components are in `/example-crates`:
 - [`example_cli`](./example-crates/example_cli): Library used by the `example_*` crates. Provides utilities for syncing, showing the balance, generating addresses and creating transactions without using the bdk `Wallet`.
 - [`example_electrum`](./example-crates/example_electrum): A command line Bitcoin wallet application built on top of `example_cli` and the `electrum` crate. It shows the power of the bdk tools (`chain` + `file_store` + `electrum`), without depending on the main `bdk` library.
- [`example_esplora`](./example-crates/example_esplora): A command line Bitcoin wallet application built on top of `example_cli` and the `esplora` crate. It shows the power of the bdk tools (`chain` + `file_store` + `esplora`), without depending on the main `bdk` library.
- [`example_bitcoind_rpc_polling`](./example-crates/example_bitcoind_rpc_polling): A command line Bitcoin wallet application built on top of `example_cli` and the `bitcoind_rpc` crate. It shows the power of the bdk tools (`chain` + `file_store` + `bitcoind_rpc`), without depending on the main `bdk` library.
 - [`wallet_esplora_blocking`](./example-crates/wallet_esplora_blocking): Uses the `Wallet` to sync and spend using the Esplora blocking interface.
 - [`wallet_esplora_async`](./example-crates/wallet_esplora_async): Uses the `Wallet` to sync and spend using the Esplora asynchronous interface.
 - [`wallet_electrum`](./example-crates/wallet_electrum): Uses the `Wallet` to sync and spend using Electrum.
@@ -62,21 +60,51 @@ Fully working examples of how to use these components are in `/example-crates`:
 [`bdk_chain`]: https://docs.rs/bdk-chain/

 ## Minimum Supported Rust Version (MSRV)
-This library should compile with any combination of features with Rust 1.63.0.
+This library should compile with any combination of features with Rust 1.57.0.

 To build with the MSRV you will need to pin dependencies as follows:

 ```shell
-# zip 0.6.3 has MSRV 1.64.0
+# log 0.4.19 has MSRV 1.60.0+
+cargo update -p log --precise "0.4.18"
+# tempfile 3.7.0 has MSRV 1.63.0+
+cargo update -p tempfile --precise "3.6.0"
+# reqwest 0.11.19 has MSRV 1.63.0+
+cargo update -p reqwest --precise "0.11.18"
+# hyper-rustls 0.24.1 has MSRV 1.60.0+
+cargo update -p hyper-rustls --precise 0.24.0
+# rustls 0.21.7 has MSRV 1.60.0+
+cargo update -p rustls:0.21.9 --precise "0.21.1"
+# rustls 0.20.9 has MSRV 1.60.0+
+cargo update -p rustls:0.20.9 --precise "0.20.8"
+# tokio 1.33 has MSRV 1.63.0+
+cargo update -p tokio --precise "1.29.1"
+# tokio-util 0.7.9 doesn't build with MSRV 1.57.0
+cargo update -p tokio-util --precise "0.7.8"
+# flate2 1.0.27 has MSRV 1.63.0+
+cargo update -p flate2 --precise "1.0.26"
+# h2 0.3.21 has MSRV 1.63.0+
+cargo update -p h2 --precise "0.3.20"
+# rustls-webpki 0.100.3 has MSRV 1.60.0+
+cargo update -p rustls-webpki:0.100.3 --precise "0.100.1"
+# rustls-webpki 0.101.2 has MSRV 1.60.0+
+cargo update -p rustls-webpki:0.101.7 --precise "0.101.1"
+# zip 0.6.6 has MSRV 1.59.0+
 cargo update -p zip --precise "0.6.2"
-# time 0.3.21 has MSRV 1.65.0
-cargo update -p time --precise "0.3.20"
-# jobserver 0.1.27 has MSRV 1.66.0
+# time 0.3.14 has MSRV 1.59.0+
+cargo update -p time --precise "0.3.13"
+# byteorder 1.5.0 has MSRV 1.60.0+
+cargo update -p byteorder --precise "1.4.3"
+# webpki 0.22.4 requires `ring:0.17.2` which has MSRV 1.61.0+
+cargo update -p webpki --precise "0.22.2"
+# os_str_bytes 6.6.0 has MSRV 1.61.0+
+cargo update -p os_str_bytes --precise 6.5.1
+# sct 0.7.1 has MSRV 1.61.0+
+cargo update -p sct --precise 0.7.0
+# cc 1.0.82 has MSRV 1.61.0+
+cargo update -p cc --precise "1.0.81"
+# jobserver 0.1.27 has MSRV 1.66.0+
 cargo update -p jobserver --precise "0.1.26"
-# home 0.5.9 has MSRV 1.70.0
-cargo update -p home --precise "0.5.5"
-# proptest 1.4.0 has MSRV 1.65.0
-cargo update -p proptest --precise "1.2.0"
 ```

 ## License
--- a/clippy.toml
+++ b/clippy.toml
@@ -1 +1 @@
-msrv="1.63.0"
+msrv="1.57.0"
--- a/crates/bdk/Cargo.toml
+++ b/crates/bdk/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "bdk"
 homepage = "https://bitcoindevkit.org"
-version = "1.0.0-alpha.9"
+version = "1.0.0-alpha.2"
 repository = "https://github.com/bitcoindevkit/bdk"
 documentation = "https://docs.rs/bdk"
 description = "A modern, lightweight, descriptor-based wallet library"
@@ -10,18 +10,19 @@ readme = "README.md"
 license = "MIT OR Apache-2.0"
 authors = ["Bitcoin Dev Kit Developers"]
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.57"

 [dependencies]
 rand = "^0.8"
-miniscript = { version = "11.0.0", features = ["serde"], default-features = false }
-bitcoin = { version = "0.31.0", features = ["serde", "base64", "rand-std"], default-features = false }
+miniscript = { version = "10.0.0", features = ["serde"], default-features = false }
+bitcoin = { version = "0.30.0", features = ["serde", "base64", "rand-std"], default-features = false }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
-bdk_chain = { path = "../chain", version = "0.12.0", features = ["miniscript", "serde"], default-features = false }
+bdk_chain = { path = "../chain", version = "0.6.0", features = ["miniscript", "serde"], default-features = false }

 # Optional dependencies
-bip39 = { version = "2.0", optional = true }
+hwi = { version = "0.7.0", optional = true, features = [ "miniscript"] }
+bip39 = { version = "1.0.1", optional = true }

 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = "0.2"
@@ -33,6 +34,8 @@ std = ["bitcoin/std", "miniscript/std", "bdk_chain/std"]
 compiler = ["miniscript/compiler"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
+hardware-signer = ["hwi"]
+test-hardware-signer = ["hardware-signer"]

 # This feature is used to run `cargo check` in our CI targeting wasm. It's not recommended
 # for libraries to explicitly include the "getrandom/js" feature, so we only do it when
--- a/crates/bdk/README.md
+++ b/crates/bdk/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/2022/08/11/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%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>

@@ -26,7 +26,7 @@

 ## `bdk`

-The `bdk` crate provides the [`Wallet`] type which is a simple, high-level
+The `bdk` crate provides the [`Wallet`](`crate::Wallet`) type which is a simple, high-level
 interface built from the low-level components of [`bdk_chain`]. `Wallet` is a good starting point
 for many simple applications as well as a good demonstration of how to use the other mechanisms to
 construct a wallet. It has two keychains (external and internal) which are defined by
@@ -34,51 +34,51 @@ construct a wallet. It has two keychains (external and internal) which are defin
 chain data it also uses the descriptors to find transaction outputs owned by them. From there, you
 can create and sign transactions.

-For details about the API of `Wallet` see the [module-level documentation][`Wallet`].
+For more information, see the [`Wallet`'s documentation](https://docs.rs/bdk/latest/bdk/wallet/struct.Wallet.html).

 ### Blockchain data

-In order to get blockchain data for `Wallet` to consume, you should configure a client from
-an available chain source. Typically you make a request to the chain source and get a response
-that the `Wallet` can use to update its view of the chain.
+In order to get blockchain data for `Wallet` to consume, you have to put it into particular form.
+Right now this is [`KeychainScan`] which is defined in [`bdk_chain`].
+
+This can be created manually or from blockchain-scanning crates.

 **Blockchain Data Sources**

 * [`bdk_esplora`]: Grabs blockchain data from Esplora for updating BDK structures.
 * [`bdk_electrum`]: Grabs blockchain data from Electrum for updating BDK structures.
-* [`bdk_bitcoind_rpc`]: Grabs blockchain data from Bitcoin Core for updating BDK structures.

 **Examples**

-* [`example-crates/wallet_esplora_async`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora_async)
-* [`example-crates/wallet_esplora_blocking`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora_blocking)
+* [`example-crates/wallet_esplora`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora)
 * [`example-crates/wallet_electrum`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_electrum)
-* [`example-crates/wallet_rpc`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_rpc)

 ### Persistence

-To persist the `Wallet` on disk, it must be constructed with a [`PersistBackend`] implementation.
+To persist the `Wallet` on disk, `Wallet` needs to be constructed with a
+[`Persist`](https://docs.rs/bdk_chain/latest/bdk_chain/keychain/struct.KeychainPersist.html) implementation.

 **Implementations**

-* [`bdk_file_store`]: A simple flat-file implementation of [`PersistBackend`].
+* [`bdk_file_store`]: a simple flat-file implementation of `Persist`.

 **Example**

-<!-- compile_fail because outpoint and txout are fake variables -->
-```rust,compile_fail
-use bdk::{bitcoin::Network, wallet::{ChangeSet, Wallet}};
+```rust
+use bdk::{bitcoin::Network, wallet::{AddressIndex, Wallet}};

 fn main() {
-    // Create a new file `Store`.
-    let db = bdk_file_store::Store::<ChangeSet>::open_or_create_new(b"magic_bytes", "path/to/my_wallet.db").expect("create store");
+    // a type that implements `Persist`
+    let db = ();

-    let descriptor = "wpkh(tprv8ZgxMBicQKsPdcAqYBpzAFwU5yxBUo88ggoBqu1qPcHUfSbKK1sKMLmC7EAk438btHQrSdu3jGGQa6PA71nvH5nkDexhLteJqkM4dQmWF9g/84'/1'/0'/0/*)";
-    let mut wallet = Wallet::new_or_load(descriptor, None, db, Network::Testnet).expect("create or load wallet");
+    let descriptor = "wpkh(tprv8ZgxMBicQKsPdy6LMhUtFHAgpocR8GC6QmwMSFpZs7h6Eziw3SpThFfczTDh5rW2krkqffa11UpX3XkeTTB2FvzZKWXqPY54Y6Rq4AQ5R8L/84'/0'/0'/0/*)";
+    let mut wallet = Wallet::new(descriptor, None, db, Network::Testnet).expect("should create");

-    // Insert a single `TxOut` at `OutPoint` into the wallet.
-    let _ = wallet.insert_txout(outpoint, txout);
-    wallet.commit().expect("must write to database");
+    // get a new address (this increments revealed derivation index)
+    println!("revealed address: {}", wallet.get_address(AddressIndex::New));
+    println!("staged changes: {:?}", wallet.staged());
+    // persist changes
+    wallet.commit().expect("must save");
 }
 ```

@@ -218,11 +218,9 @@ submitted for inclusion in the work by you, as defined in the Apache-2.0
 license, shall be dual licensed as above, without any additional terms or
 conditions.

-[`Wallet`]: https://docs.rs/bdk/1.0.0-alpha.7/bdk/wallet/struct.Wallet.html
-[`PersistBackend`]: https://docs.rs/bdk_chain/latest/bdk_chain/trait.PersistBackend.html
 [`bdk_chain`]: https://docs.rs/bdk_chain/latest
 [`bdk_file_store`]: https://docs.rs/bdk_file_store/latest
 [`bdk_electrum`]: https://docs.rs/bdk_electrum/latest
 [`bdk_esplora`]: https://docs.rs/bdk_esplora/latest
-[`bdk_bitcoind_rpc`]: https://docs.rs/bdk_bitcoind_rpc/latest
+[`KeychainScan`]: https://docs.rs/bdk_chain/latest/bdk_chain/keychain/struct.KeychainScan.html
 [`rust-miniscript`]: https://docs.rs/miniscript/latest/miniscript/index.html
--- a/crates/bdk/examples/mnemonic_to_descriptors.rs
+++ b/crates/bdk/examples/mnemonic_to_descriptors.rs
@@ -33,8 +33,8 @@ fn main() -> Result<(), anyhow::Error> {
    let mnemonic_with_passphrase = (mnemonic, None);

    // define external and internal derivation key path
-    let external_path = DerivationPath::from_str("m/86h/1h/0h/0").unwrap();
-    let internal_path = DerivationPath::from_str("m/86h/1h/0h/1").unwrap();
+    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) =
--- a/crates/bdk/src/descriptor/checksum.rs
+++ b/crates/bdk/src/descriptor/checksum.rs
@@ -42,16 +42,22 @@ fn poly_mod(mut c: u64, val: u64) -> u64 {
    c
 }

-/// Compute the checksum bytes of a descriptor, excludes any existing checksum in the descriptor string from the calculation
-pub fn calc_checksum_bytes(mut desc: &str) -> Result<[u8; 8], DescriptorError> {
+/// Computes the checksum bytes of a descriptor.
+/// `exclude_hash = true` ignores all data after the first '#' (inclusive).
+pub(crate) fn calc_checksum_bytes_internal(
+    mut desc: &str,
+    exclude_hash: bool,
+) -> Result<[u8; 8], DescriptorError> {
    let mut c = 1;
    let mut cls = 0;
    let mut clscount = 0;

    let mut original_checksum = None;
-    if let Some(split) = desc.split_once('#') {
-        desc = split.0;
-        original_checksum = Some(split.1);
+    if exclude_hash {
+        if let Some(split) = desc.split_once('#') {
+            desc = split.0;
+            original_checksum = Some(split.1);
+        }
    }

    for ch in desc.as_bytes() {
@@ -89,10 +95,39 @@ pub fn calc_checksum_bytes(mut desc: &str) -> Result<[u8; 8], DescriptorError> {
    Ok(checksum)
 }

+/// Compute the checksum bytes of a descriptor, excludes any existing checksum in the descriptor string from the calculation
+pub fn calc_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
+    calc_checksum_bytes_internal(desc, true)
+}
+
 /// Compute the checksum of a descriptor, excludes any existing checksum in the descriptor string from the calculation
 pub fn calc_checksum(desc: &str) -> Result<String, DescriptorError> {
    // unsafe is okay here as the checksum only uses bytes in `CHECKSUM_CHARSET`
-    calc_checksum_bytes(desc).map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
+    calc_checksum_bytes_internal(desc, true)
+        .map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
+}
+
+// TODO in release 0.25.0, remove get_checksum_bytes and get_checksum
+// TODO in release 0.25.0, consolidate calc_checksum_bytes_internal into calc_checksum_bytes
+
+/// Compute the checksum bytes of a descriptor
+#[deprecated(
+    since = "0.24.0",
+    note = "Use new `calc_checksum_bytes` function which excludes any existing checksum in the descriptor string before calculating the checksum hash bytes. See https://github.com/bitcoindevkit/bdk/pull/765."
+)]
+pub fn get_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
+    calc_checksum_bytes_internal(desc, false)
+}
+
+/// Compute the checksum of a descriptor
+#[deprecated(
+    since = "0.24.0",
+    note = "Use new `calc_checksum` function which excludes any existing checksum in the descriptor string before calculating the checksum hash. See https://github.com/bitcoindevkit/bdk/pull/765."
+)]
+pub fn get_checksum(desc: &str) -> Result<String, DescriptorError> {
+    // unsafe is okay here as the checksum only uses bytes in `CHECKSUM_CHARSET`
+    calc_checksum_bytes_internal(desc, false)
+        .map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
 }

 #[cfg(test)]
--- a/crates/bdk/src/descriptor/dsl.rs
+++ b/crates/bdk/src/descriptor/dsl.rs
@@ -274,13 +274,14 @@ macro_rules! impl_sortedmulti {
 #[macro_export]
 macro_rules! parse_tap_tree {
    ( @merge $tree_a:expr, $tree_b:expr) => {{
+        use $crate::alloc::sync::Arc;
        use $crate::miniscript::descriptor::TapTree;

        $tree_a
            .and_then(|tree_a| Ok((tree_a, $tree_b?)))
            .and_then(|((a_tree, mut a_keymap, a_networks), (b_tree, b_keymap, b_networks))| {
                a_keymap.extend(b_keymap.into_iter());
-                Ok((TapTree::combine(a_tree, b_tree), a_keymap, $crate::keys::merge_networks(&a_networks, &b_networks)))
+                Ok((TapTree::Tree(Arc::new(a_tree), Arc::new(b_tree)), a_keymap, $crate::keys::merge_networks(&a_networks, &b_networks)))
            })

    }};
@@ -805,7 +806,7 @@ mod test {
    use crate::descriptor::{DescriptorError, DescriptorMeta};
    use crate::keys::{DescriptorKey, IntoDescriptorKey, ValidNetworks};
    use bitcoin::bip32;
-    use bitcoin::Network::{Bitcoin, Regtest, Signet, Testnet};
+    use bitcoin::network::constants::Network::{Bitcoin, Regtest, Signet, Testnet};
    use bitcoin::PrivateKey;

    // test the descriptor!() macro
@@ -935,7 +936,7 @@ mod test {

    #[test]
    fn test_bip32_legacy_descriptors() {
-        let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();

        let path = bip32::DerivationPath::from_str("m/0").unwrap();
        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
@@ -980,7 +981,7 @@ mod test {

    #[test]
    fn test_bip32_segwitv0_descriptors() {
-        let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();

        let path = bip32::DerivationPath::from_str("m/0").unwrap();
        let desc_key = (xprv, path.clone()).into_descriptor_key().unwrap();
@@ -1037,10 +1038,10 @@ mod test {

    #[test]
    fn test_dsl_sortedmulti() {
-        let key_1 = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let key_1 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        let path_1 = bip32::DerivationPath::from_str("m/0").unwrap();

-        let key_2 = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPegBHHnq7YEgM815dG24M2Jk5RVqipgDxF1HJ1tsnT815X5Fd5FRfMVUs8NZs9XCb6y9an8hRPThnhfwfXJ36intaekySHGF").unwrap();
+        let key_2 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPegBHHnq7YEgM815dG24M2Jk5RVqipgDxF1HJ1tsnT815X5Fd5FRfMVUs8NZs9XCb6y9an8hRPThnhfwfXJ36intaekySHGF").unwrap();
        let path_2 = bip32::DerivationPath::from_str("m/1").unwrap();

        let desc_key1 = (key_1, path_1);
@@ -1096,7 +1097,7 @@ mod test {
    // - verify the valid_networks returned is correctly computed based on the keys present in the descriptor
    #[test]
    fn test_valid_networks() {
-        let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        let path = bip32::DerivationPath::from_str("m/0").unwrap();
        let desc_key = (xprv, path).into_descriptor_key().unwrap();

@@ -1106,7 +1107,7 @@ mod test {
            [Testnet, Regtest, Signet].iter().cloned().collect()
        );

-        let xprv = bip32::Xpriv::from_str("xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi").unwrap();
        let path = bip32::DerivationPath::from_str("m/10/20/30/40").unwrap();
        let desc_key = (xprv, path).into_descriptor_key().unwrap();

@@ -1119,15 +1120,15 @@ mod test {
    fn test_key_maps_merged() {
        let secp = Secp256k1::new();

-        let xprv1 = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let xprv1 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        let path1 = bip32::DerivationPath::from_str("m/0").unwrap();
        let desc_key1 = (xprv1, path1.clone()).into_descriptor_key().unwrap();

-        let xprv2 = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPegBHHnq7YEgM815dG24M2Jk5RVqipgDxF1HJ1tsnT815X5Fd5FRfMVUs8NZs9XCb6y9an8hRPThnhfwfXJ36intaekySHGF").unwrap();
+        let xprv2 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPegBHHnq7YEgM815dG24M2Jk5RVqipgDxF1HJ1tsnT815X5Fd5FRfMVUs8NZs9XCb6y9an8hRPThnhfwfXJ36intaekySHGF").unwrap();
        let path2 = bip32::DerivationPath::from_str("m/2147483647'/0").unwrap();
        let desc_key2 = (xprv2, path2.clone()).into_descriptor_key().unwrap();

-        let xprv3 = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPdZXrcHNLf5JAJWFAoJ2TrstMRdSKtEggz6PddbuSkvHKM9oKJyFgZV1B7rw8oChspxyYbtmEXYyg1AjfWbL3ho3XHDpHRZf").unwrap();
+        let xprv3 = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPdZXrcHNLf5JAJWFAoJ2TrstMRdSKtEggz6PddbuSkvHKM9oKJyFgZV1B7rw8oChspxyYbtmEXYyg1AjfWbL3ho3XHDpHRZf").unwrap();
        let path3 = bip32::DerivationPath::from_str("m/10/20/30/40").unwrap();
        let desc_key3 = (xprv3, path3.clone()).into_descriptor_key().unwrap();

@@ -1151,7 +1152,7 @@ mod test {
    #[test]
    fn test_script_context_validation() {
        // this compiles
-        let xprv = bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        let path = bip32::DerivationPath::from_str("m/0").unwrap();
        let desc_key: DescriptorKey<Legacy> = (xprv, path).into_descriptor_key().unwrap();

--- a/crates/bdk/src/descriptor/error.rs
+++ b/crates/bdk/src/descriptor/error.rs
@@ -41,7 +41,7 @@ pub enum Error {
    /// Miniscript error
    Miniscript(miniscript::Error),
    /// Hex decoding error
-    Hex(bitcoin::hex::HexToBytesError),
+    Hex(bitcoin::hashes::hex::Error),
 }

 impl From<crate::keys::KeyError> for Error {
@@ -110,8 +110,8 @@ impl From<miniscript::Error> for Error {
    }
 }

-impl From<bitcoin::hex::HexToBytesError> for Error {
-    fn from(err: bitcoin::hex::HexToBytesError) -> Self {
+impl From<bitcoin::hashes::hex::Error> for Error {
+    fn from(err: bitcoin::hashes::hex::Error) -> Self {
        Error::Hex(err)
    }
 }
--- a/crates/bdk/src/descriptor/mod.rs
+++ b/crates/bdk/src/descriptor/mod.rs
@@ -18,7 +18,7 @@ use crate::collections::BTreeMap;
 use alloc::string::String;
 use alloc::vec::Vec;

-use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, KeySource, Xpub};
+use bitcoin::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint, KeySource};
 use bitcoin::{key::XOnlyPublicKey, secp256k1, PublicKey};
 use bitcoin::{psbt, taproot};
 use bitcoin::{Network, TxOut};
@@ -377,7 +377,7 @@ where
 pub(crate) trait DescriptorMeta {
    fn is_witness(&self) -> bool;
    fn is_taproot(&self) -> bool;
-    fn get_extended_keys(&self) -> Vec<DescriptorXKey<Xpub>>;
+    fn get_extended_keys(&self) -> Vec<DescriptorXKey<ExtendedPubKey>>;
    fn derive_from_hd_keypaths(
        &self,
        hd_keypaths: &HdKeyPaths,
@@ -418,7 +418,7 @@ impl DescriptorMeta for ExtendedDescriptor {
        self.desc_type() == DescriptorType::Tr
    }

-    fn get_extended_keys(&self) -> Vec<DescriptorXKey<Xpub>> {
+    fn get_extended_keys(&self) -> Vec<DescriptorXKey<ExtendedPubKey>> {
        let mut answer = Vec::new();

        self.for_each_key(|pk| {
@@ -438,20 +438,21 @@ impl DescriptorMeta for ExtendedDescriptor {
        secp: &SecpCtx,
    ) -> Option<DerivedDescriptor> {
        // Ensure that deriving `xpub` with `path` yields `expected`
-        let verify_key =
-            |xpub: &DescriptorXKey<Xpub>, path: &DerivationPath, expected: &SinglePubKey| {
-                let derived = xpub
-                    .xkey
-                    .derive_pub(secp, path)
-                    .expect("The path should never contain hardened derivation steps")
-                    .public_key;
+        let verify_key = |xpub: &DescriptorXKey<ExtendedPubKey>,
+                          path: &DerivationPath,
+                          expected: &SinglePubKey| {
+            let derived = xpub
+                .xkey
+                .derive_pub(secp, path)
+                .expect("The path should never contain hardened derivation steps")
+                .public_key;

-                match expected {
-                    SinglePubKey::FullKey(pk) if &PublicKey::new(derived) == pk => true,
-                    SinglePubKey::XOnly(pk) if &XOnlyPublicKey::from(derived) == pk => true,
-                    _ => false,
-                }
-            };
+            match expected {
+                SinglePubKey::FullKey(pk) if &PublicKey::new(derived) == pk => true,
+                SinglePubKey::XOnly(pk) if &XOnlyPublicKey::from(derived) == pk => true,
+                _ => false,
+            }
+        };

        let mut path_found = None;

@@ -604,10 +605,10 @@ mod test {
    use core::str::FromStr;

    use assert_matches::assert_matches;
-    use bitcoin::hex::FromHex;
+    use bitcoin::hashes::hex::FromHex;
    use bitcoin::secp256k1::Secp256k1;
    use bitcoin::ScriptBuf;
-    use bitcoin::{bip32, Psbt};
+    use bitcoin::{bip32, psbt::Psbt};

    use super::*;
    use crate::psbt::PsbtUtils;
@@ -726,7 +727,7 @@ mod test {

        let secp = Secp256k1::new();

-        let xprv = bip32::Xpriv::from_str("xprv9s21ZrQH143K3c3gF1DUWpWNr2SG2XrG8oYPpqYh7hoWsJy9NjabErnzriJPpnGHyKz5NgdXmq1KVbqS1r4NXdCoKitWg5e86zqXHa8kxyB").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
@@ -745,7 +746,7 @@ mod test {
        let mut xprv_testnet = xprv;
        xprv_testnet.network = Network::Testnet;

-        let xpub_testnet = bip32::Xpub::from_priv(&secp, &xprv_testnet);
+        let xpub_testnet = bip32::ExtendedPubKey::from_priv(&secp, &xprv_testnet);
        let desc_pubkey = DescriptorPublicKey::XPub(DescriptorXKey {
            xkey: xpub_testnet,
            origin: None,
@@ -835,7 +836,7 @@ mod test {
    fn test_descriptor_from_str_from_output_of_macro() {
        let secp = Secp256k1::new();

-        let tpub = bip32::Xpub::from_str("tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK").unwrap();
+        let tpub = bip32::ExtendedPubKey::from_str("tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK").unwrap();
        let path = bip32::DerivationPath::from_str("m/1/2").unwrap();
        let key = (tpub, path).into_descriptor_key().unwrap();

@@ -894,7 +895,7 @@ mod test {
            .update_with_descriptor_unchecked(&descriptor)
            .unwrap();

-        assert_eq!(psbt_input.redeem_script, Some(script.to_p2wsh()));
+        assert_eq!(psbt_input.redeem_script, Some(script.to_v0_p2wsh()));
        assert_eq!(psbt_input.witness_script, Some(script));
    }
 }
--- a/crates/bdk/src/descriptor/policy.rs
+++ b/crates/bdk/src/descriptor/policy.rs
@@ -1137,7 +1137,7 @@ impl ExtractPolicy for Descriptor<DescriptorPublicKey> {
                let key_spend_sig =
                    miniscript::Tap::make_signature(tr.internal_key(), signers, build_sat, secp);

-                if tr.tap_tree().is_none() {
+                if tr.taptree().is_none() {
                    Ok(Some(key_spend_sig))
                } else {
                    let mut items = vec![key_spend_sig];
@@ -1184,8 +1184,8 @@ mod test {
        secp: &SecpCtx,
    ) -> (DescriptorKey<Ctx>, DescriptorKey<Ctx>, Fingerprint) {
        let path = bip32::DerivationPath::from_str(path).unwrap();
-        let tprv = bip32::Xpriv::from_str(tprv).unwrap();
-        let tpub = bip32::Xpub::from_priv(secp, &tprv);
+        let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
+        let tpub = bip32::ExtendedPubKey::from_priv(secp, &tprv);
        let fingerprint = tprv.fingerprint(secp);
        let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
        let pubkey = (tpub, path).into_descriptor_key().unwrap();
--- a/crates/bdk/src/descriptor/template.rs
+++ b/crates/bdk/src/descriptor/template.rs
@@ -195,7 +195,7 @@ impl<K: IntoDescriptorKey<Tap>> DescriptorTemplate for P2TR<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip44;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip44(key.clone(), KeychainKind::External),
 ///     Some(Bip44(key, KeychainKind::Internal)),
@@ -232,7 +232,7 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip44Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip44Public(key.clone(), fingerprint, KeychainKind::External),
@@ -270,7 +270,7 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44Public<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip49;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip49(key.clone(), KeychainKind::External),
 ///     Some(Bip49(key, KeychainKind::Internal)),
@@ -307,7 +307,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip49Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip49Public(key.clone(), fingerprint, KeychainKind::External),
@@ -345,7 +345,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49Public<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip84;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip84(key.clone(), KeychainKind::External),
 ///     Some(Bip84(key, KeychainKind::Internal)),
@@ -382,7 +382,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip84Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip84Public(key.clone(), fingerprint, KeychainKind::External),
@@ -420,7 +420,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84Public<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip86;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip86(key.clone(), KeychainKind::External),
 ///     Some(Bip86(key, KeychainKind::Internal)),
@@ -457,7 +457,7 @@ impl<K: DerivableKey<Tap>> DescriptorTemplate for Bip86<K> {
 /// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip86Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip86Public(key.clone(), fingerprint, KeychainKind::External),
@@ -567,7 +567,7 @@ mod test {
    fn test_bip44_template_cointype() {
        use bitcoin::bip32::ChildNumber::{self, Hardened};

-        let xprvkey = bitcoin::bip32::Xpriv::from_str("xprv9s21ZrQH143K2fpbqApQL69a4oKdGVnVN52R82Ft7d1pSqgKmajF62acJo3aMszZb6qQ22QsVECSFxvf9uyxFUvFYQMq3QbtwtRSMjLAhMf").unwrap();
+        let xprvkey = bitcoin::bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K2fpbqApQL69a4oKdGVnVN52R82Ft7d1pSqgKmajF62acJo3aMszZb6qQ22QsVECSFxvf9uyxFUvFYQMq3QbtwtRSMjLAhMf").unwrap();
        assert_eq!(Network::Bitcoin, xprvkey.network);
        let xdesc = Bip44(xprvkey, KeychainKind::Internal)
            .build(Network::Bitcoin)
@@ -575,13 +575,13 @@ mod test {

        if let ExtendedDescriptor::Pkh(pkh) = xdesc.0 {
            let path: Vec<ChildNumber> = pkh.into_inner().full_derivation_path().unwrap().into();
-            let purpose = path.first().unwrap();
+            let purpose = path.get(0).unwrap();
            assert_matches!(purpose, Hardened { index: 44 });
            let coin_type = path.get(1).unwrap();
            assert_matches!(coin_type, Hardened { index: 0 });
        }

-        let tprvkey = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let tprvkey = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        assert_eq!(Network::Testnet, tprvkey.network);
        let tdesc = Bip44(tprvkey, KeychainKind::Internal)
            .build(Network::Testnet)
@@ -589,7 +589,7 @@ mod test {

        if let ExtendedDescriptor::Pkh(pkh) = tdesc.0 {
            let path: Vec<ChildNumber> = pkh.into_inner().full_derivation_path().unwrap().into();
-            let purpose = path.first().unwrap();
+            let purpose = path.get(0).unwrap();
            assert_matches!(purpose, Hardened { index: 44 });
            let coin_type = path.get(1).unwrap();
            assert_matches!(coin_type, Hardened { index: 1 });
@@ -740,7 +740,7 @@ mod test {
    // BIP44 `pkh(key/44'/0'/0'/{0,1}/*)`
    #[test]
    fn test_bip44_template() {
-        let prvkey = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let prvkey = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        check(
            Bip44(prvkey, KeychainKind::External).build(Network::Bitcoin),
            false,
@@ -770,7 +770,7 @@ mod test {
    // BIP44 public `pkh(key/{0,1}/*)`
    #[test]
    fn test_bip44_public_template() {
-        let pubkey = bitcoin::bip32::Xpub::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU").unwrap();
+        let pubkey = bitcoin::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU").unwrap();
        let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f").unwrap();
        check(
            Bip44Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
@@ -801,7 +801,7 @@ mod test {
    // BIP49 `sh(wpkh(key/49'/0'/0'/{0,1}/*))`
    #[test]
    fn test_bip49_template() {
-        let prvkey = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let prvkey = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        check(
            Bip49(prvkey, KeychainKind::External).build(Network::Bitcoin),
            true,
@@ -831,7 +831,7 @@ mod test {
    // BIP49 public `sh(wpkh(key/{0,1}/*))`
    #[test]
    fn test_bip49_public_template() {
-        let pubkey = bitcoin::bip32::Xpub::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L").unwrap();
+        let pubkey = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L").unwrap();
        let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f").unwrap();
        check(
            Bip49Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
@@ -862,7 +862,7 @@ mod test {
    // BIP84 `wpkh(key/84'/0'/0'/{0,1}/*)`
    #[test]
    fn test_bip84_template() {
-        let prvkey = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
+        let prvkey = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
        check(
            Bip84(prvkey, KeychainKind::External).build(Network::Bitcoin),
            true,
@@ -892,7 +892,7 @@ mod test {
    // BIP84 public `wpkh(key/{0,1}/*)`
    #[test]
    fn test_bip84_public_template() {
-        let pubkey = bitcoin::bip32::Xpub::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q").unwrap();
+        let pubkey = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q").unwrap();
        let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f").unwrap();
        check(
            Bip84Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
@@ -924,7 +924,7 @@ mod test {
    // Used addresses in test vector in https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki
    #[test]
    fn test_bip86_template() {
-        let prvkey = bitcoin::bip32::Xpriv::from_str("xprv9s21ZrQH143K3GJpoapnV8SFfukcVBSfeCficPSGfubmSFDxo1kuHnLisriDvSnRRuL2Qrg5ggqHKNVpxR86QEC8w35uxmGoggxtQTPvfUu").unwrap();
+        let prvkey = bitcoin::bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3GJpoapnV8SFfukcVBSfeCficPSGfubmSFDxo1kuHnLisriDvSnRRuL2Qrg5ggqHKNVpxR86QEC8w35uxmGoggxtQTPvfUu").unwrap();
        check(
            Bip86(prvkey, KeychainKind::External).build(Network::Bitcoin),
            false,
@@ -955,7 +955,7 @@ mod test {
    // Used addresses in test vector in https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki
    #[test]
    fn test_bip86_public_template() {
-        let pubkey = bitcoin::bip32::Xpub::from_str("xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ").unwrap();
+        let pubkey = bitcoin::bip32::ExtendedPubKey::from_str("xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ").unwrap();
        let fingerprint = bitcoin::bip32::Fingerprint::from_str("73c5da0a").unwrap();
        check(
            Bip86Public(pubkey, fingerprint, KeychainKind::External).build(Network::Bitcoin),
--- a/crates/bdk/src/keys/bip39.rs
+++ b/crates/bdk/src/keys/bip39.rs
@@ -57,7 +57,7 @@ pub type MnemonicWithPassphrase = (Mnemonic, Option<String>);
 #[cfg_attr(docsrs, doc(cfg(feature = "keys-bip39")))]
 impl<Ctx: ScriptContext> DerivableKey<Ctx> for Seed {
    fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
-        Ok(bip32::Xpriv::new_master(Network::Bitcoin, &self[..])?.into())
+        Ok(bip32::ExtendedPrivKey::new_master(Network::Bitcoin, &self[..])?.into())
    }

    fn into_descriptor_key(
--- a/crates/bdk/src/keys/mod.rs
+++ b/crates/bdk/src/keys/mod.rs
@@ -110,7 +110,7 @@ impl<Ctx: ScriptContext> DescriptorKey<Ctx> {
                Ok((public, KeyMap::default(), valid_networks))
            }
            DescriptorKey::Secret(secret, valid_networks, _) => {
-                let mut key_map = KeyMap::new();
+                let mut key_map = KeyMap::with_capacity(1);

                let public = secret
                    .to_public(secp)
@@ -309,15 +309,15 @@ pub trait IntoDescriptorKey<Ctx: ScriptContext>: Sized {

 /// Enum for extended keys that can be either `xprv` or `xpub`
 ///
-/// An instance of [`ExtendedKey`] can be constructed from an [`Xpriv`](bip32::Xpriv)
-/// or an [`Xpub`](bip32::Xpub) by using the `From` trait.
+/// An instance of [`ExtendedKey`] can be constructed from an [`ExtendedPrivKey`](bip32::ExtendedPrivKey)
+/// or an [`ExtendedPubKey`](bip32::ExtendedPubKey) by using the `From` trait.
 ///
 /// Defaults to the [`Legacy`](miniscript::Legacy) context.
 pub enum ExtendedKey<Ctx: ScriptContext = miniscript::Legacy> {
    /// A private extended key, aka an `xprv`
-    Private((bip32::Xpriv, PhantomData<Ctx>)),
+    Private((bip32::ExtendedPrivKey, PhantomData<Ctx>)),
    /// A public extended key, aka an `xpub`
-    Public((bip32::Xpub, PhantomData<Ctx>)),
+    Public((bip32::ExtendedPubKey, PhantomData<Ctx>)),
 }

 impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
@@ -329,9 +329,9 @@ impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
        }
    }

-    /// Transform the [`ExtendedKey`] into an [`Xpriv`](bip32::Xpriv) for the
+    /// Transform the [`ExtendedKey`] into an [`ExtendedPrivKey`](bip32::ExtendedPrivKey) for the
    /// given [`Network`], if the key contains the private data
-    pub fn into_xprv(self, network: Network) -> Option<bip32::Xpriv> {
+    pub fn into_xprv(self, network: Network) -> Option<bip32::ExtendedPrivKey> {
        match self {
            ExtendedKey::Private((mut xprv, _)) => {
                xprv.network = network;
@@ -341,15 +341,15 @@ impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
        }
    }

-    /// Transform the [`ExtendedKey`] into an [`Xpub`](bip32::Xpub) for the
+    /// Transform the [`ExtendedKey`] into an [`ExtendedPubKey`](bip32::ExtendedPubKey) for the
    /// given [`Network`]
    pub fn into_xpub<C: Signing>(
        self,
        network: bitcoin::Network,
        secp: &Secp256k1<C>,
-    ) -> bip32::Xpub {
+    ) -> bip32::ExtendedPubKey {
        let mut xpub = match self {
-            ExtendedKey::Private((xprv, _)) => bip32::Xpub::from_priv(secp, &xprv),
+            ExtendedKey::Private((xprv, _)) => bip32::ExtendedPubKey::from_priv(secp, &xprv),
            ExtendedKey::Public((xpub, _)) => xpub,
        };

@@ -358,14 +358,14 @@ impl<Ctx: ScriptContext> ExtendedKey<Ctx> {
    }
 }

-impl<Ctx: ScriptContext> From<bip32::Xpub> for ExtendedKey<Ctx> {
-    fn from(xpub: bip32::Xpub) -> Self {
+impl<Ctx: ScriptContext> From<bip32::ExtendedPubKey> for ExtendedKey<Ctx> {
+    fn from(xpub: bip32::ExtendedPubKey) -> Self {
        ExtendedKey::Public((xpub, PhantomData))
    }
 }

-impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
-    fn from(xprv: bip32::Xpriv) -> Self {
+impl<Ctx: ScriptContext> From<bip32::ExtendedPrivKey> for ExtendedKey<Ctx> {
+    fn from(xprv: bip32::ExtendedPrivKey) -> Self {
        ExtendedKey::Private((xprv, PhantomData))
    }
 }
@@ -383,8 +383,8 @@ impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
 ///
 /// ## Examples
 ///
-/// Key types that can be directly converted into an [`Xpriv`] or
-/// an [`Xpub`] can implement only the required `into_extended_key()` method.
+/// Key types that can be directly converted into an [`ExtendedPrivKey`] or
+/// an [`ExtendedPubKey`] can implement only the required `into_extended_key()` method.
 ///
 /// ```
 /// use bdk::bitcoin;
@@ -399,7 +399,7 @@ impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
 ///
 /// impl<Ctx: ScriptContext> DerivableKey<Ctx> for MyCustomKeyType {
 ///     fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
-///         let xprv = bip32::Xpriv {
+///         let xprv = bip32::ExtendedPrivKey {
 ///             network: self.network,
 ///             depth: 0,
 ///             parent_fingerprint: bip32::Fingerprint::default(),
@@ -415,7 +415,7 @@ impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
 ///
 /// Types that don't internally encode the [`Network`] in which they are valid need some extra
 /// steps to override the set of valid networks, otherwise only the network specified in the
-/// [`Xpriv`] or [`Xpub`] will be considered valid.
+/// [`ExtendedPrivKey`] or [`ExtendedPubKey`] will be considered valid.
 ///
 /// ```
 /// use bdk::bitcoin;
@@ -431,7 +431,7 @@ impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
 ///
 /// impl<Ctx: ScriptContext> DerivableKey<Ctx> for MyCustomKeyType {
 ///     fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
-///         let xprv = bip32::Xpriv {
+///         let xprv = bip32::ExtendedPrivKey {
 ///             network: bitcoin::Network::Bitcoin, // pick an arbitrary network here
 ///             depth: 0,
 ///             parent_fingerprint: bip32::Fingerprint::default(),
@@ -459,8 +459,8 @@ impl<Ctx: ScriptContext> From<bip32::Xpriv> for ExtendedKey<Ctx> {
 /// ```
 ///
 /// [`DerivationPath`]: (bip32::DerivationPath)
-/// [`Xpriv`]: (bip32::Xpriv)
-/// [`Xpub`]: (bip32::Xpub)
+/// [`ExtendedPrivKey`]: (bip32::ExtendedPrivKey)
+/// [`ExtendedPubKey`]: (bip32::ExtendedPubKey)
 pub trait DerivableKey<Ctx: ScriptContext = miniscript::Legacy>: Sized {
    /// Consume `self` and turn it into an [`ExtendedKey`]
    #[cfg_attr(
@@ -520,13 +520,13 @@ impl<Ctx: ScriptContext> DerivableKey<Ctx> for ExtendedKey<Ctx> {
    }
 }

-impl<Ctx: ScriptContext> DerivableKey<Ctx> for bip32::Xpub {
+impl<Ctx: ScriptContext> DerivableKey<Ctx> for bip32::ExtendedPubKey {
    fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
        Ok(self.into())
    }
 }

-impl<Ctx: ScriptContext> DerivableKey<Ctx> for bip32::Xpriv {
+impl<Ctx: ScriptContext> DerivableKey<Ctx> for bip32::ExtendedPrivKey {
    fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
        Ok(self.into())
    }
@@ -670,7 +670,7 @@ where
 {
 }

-impl<Ctx: ScriptContext> GeneratableKey<Ctx> for bip32::Xpriv {
+impl<Ctx: ScriptContext> GeneratableKey<Ctx> for bip32::ExtendedPrivKey {
    type Entropy = [u8; 32];

    type Options = ();
@@ -681,7 +681,7 @@ impl<Ctx: ScriptContext> GeneratableKey<Ctx> for bip32::Xpriv {
        entropy: Self::Entropy,
    ) -> Result<GeneratedKey<Self, Ctx>, Self::Error> {
        // pick a arbitrary network here, but say that we support all of them
-        let xprv = bip32::Xpriv::new_master(Network::Bitcoin, entropy.as_ref())?;
+        let xprv = bip32::ExtendedPrivKey::new_master(Network::Bitcoin, entropy.as_ref())?;
        Ok(GeneratedKey::new(xprv, any_network()))
    }
 }
@@ -971,7 +971,7 @@ pub mod test {
    #[test]
    fn test_keys_generate_xprv() {
        let generated_xprv: GeneratedKey<_, miniscript::Segwitv0> =
-            bip32::Xpriv::generate_with_entropy_default(TEST_ENTROPY).unwrap();
+            bip32::ExtendedPrivKey::generate_with_entropy_default(TEST_ENTROPY).unwrap();

        assert_eq!(generated_xprv.valid_networks, any_network());
        assert_eq!(generated_xprv.to_string(), "xprv9s21ZrQH143K4Xr1cJyqTvuL2FWR8eicgY9boWqMBv8MDVUZ65AXHnzBrK1nyomu6wdcabRgmGTaAKawvhAno1V5FowGpTLVx3jxzE5uk3Q");
--- a/crates/bdk/src/lib.rs
+++ b/crates/bdk/src/lib.rs
@@ -17,6 +17,8 @@ extern crate std;
 pub extern crate alloc;

 pub extern crate bitcoin;
+#[cfg(feature = "hardware-signer")]
+pub extern crate hwi;
 pub extern crate miniscript;
 extern crate serde;
 extern crate serde_json;
--- a/crates/bdk/src/psbt/mod.rs
+++ b/crates/bdk/src/psbt/mod.rs
@@ -9,12 +9,11 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.

-//! Additional functions on the `rust-bitcoin` `Psbt` structure.
+//! Additional functions on the `rust-bitcoin` `PartiallySignedTransaction` structure.

+use crate::FeeRate;
 use alloc::vec::Vec;
-use bitcoin::Amount;
-use bitcoin::FeeRate;
-use bitcoin::Psbt;
+use bitcoin::psbt::PartiallySignedTransaction as Psbt;
 use bitcoin::TxOut;

 // TODO upstream the functions here to `rust-bitcoin`?
@@ -29,23 +28,31 @@ pub trait PsbtUtils {
    fn fee_amount(&self) -> Option<u64>;

    /// The transaction's fee rate. This value will only be accurate if calculated AFTER the
-    /// `Psbt` is finalized and all witness/signature data is added to the
+    /// `PartiallySignedTransaction` is finalized and all witness/signature data is added to the
    /// transaction.
    /// If the PSBT is missing a TxOut for an input returns None.
    fn fee_rate(&self) -> Option<FeeRate>;
 }

 impl PsbtUtils for Psbt {
+    #[allow(clippy::all)] // We want to allow `manual_map` but it is too new.
    fn get_utxo_for(&self, input_index: usize) -> Option<TxOut> {
        let tx = &self.unsigned_tx;
-        let input = self.inputs.get(input_index)?;

-        match (&input.witness_utxo, &input.non_witness_utxo) {
-            (Some(_), _) => input.witness_utxo.clone(),
-            (_, Some(_)) => input.non_witness_utxo.as_ref().map(|in_tx| {
-                in_tx.output[tx.input[input_index].previous_output.vout as usize].clone()
-            }),
-            _ => None,
+        if input_index >= tx.input.len() {
+            return None;
+        }
+
+        if let Some(input) = self.inputs.get(input_index) {
+            if let Some(wit_utxo) = &input.witness_utxo {
+                Some(wit_utxo.clone())
+            } else if let Some(in_tx) = &input.non_witness_utxo {
+                Some(in_tx.output[tx.input[input_index].previous_output.vout as usize].clone())
+            } else {
+                None
+            }
+        } else {
+            None
        }
    }

@@ -54,13 +61,8 @@ impl PsbtUtils for Psbt {
        let utxos: Option<Vec<TxOut>> = (0..tx.input.len()).map(|i| self.get_utxo_for(i)).collect();

        utxos.map(|inputs| {
-            let input_amount: u64 = inputs.iter().map(|i| i.value.to_sat()).sum();
-            let output_amount: u64 = self
-                .unsigned_tx
-                .output
-                .iter()
-                .map(|o| o.value.to_sat())
-                .sum();
+            let input_amount: u64 = inputs.iter().map(|i| i.value).sum();
+            let output_amount: u64 = self.unsigned_tx.output.iter().map(|o| o.value).sum();
            input_amount
                .checked_sub(output_amount)
                .expect("input amount must be greater than output amount")
@@ -69,7 +71,9 @@ impl PsbtUtils for Psbt {

    fn fee_rate(&self) -> Option<FeeRate> {
        let fee_amount = self.fee_amount();
-        let weight = self.clone().extract_tx().ok()?.weight();
-        fee_amount.map(|fee| Amount::from_sat(fee) / weight)
+        fee_amount.map(|fee| {
+            let weight = self.clone().extract_tx().weight();
+            FeeRate::from_wu(fee, weight)
+        })
    }
 }
--- a/crates/bdk/src/types.rs
+++ b/crates/bdk/src/types.rs
@@ -11,10 +11,11 @@

 use alloc::boxed::Box;
 use core::convert::AsRef;
+use core::ops::Sub;

 use bdk_chain::ConfirmationTime;
-use bitcoin::blockdata::transaction::{OutPoint, Sequence, TxOut};
-use bitcoin::psbt;
+use bitcoin::blockdata::transaction::{OutPoint, TxOut};
+use bitcoin::{psbt, Weight};

 use serde::{Deserialize, Serialize};

@@ -46,6 +47,116 @@ impl AsRef<[u8]> for KeychainKind {
    }
 }

+/// Fee rate
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
+// Internally stored as satoshi/vbyte
+pub struct FeeRate(f32);
+
+impl FeeRate {
+    /// Create a new instance checking the value provided
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    fn new_checked(value: f32) -> Self {
+        assert!(value.is_normal() || value == 0.0);
+        assert!(value.is_sign_positive());
+
+        FeeRate(value)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in sats/kwu
+    pub fn from_sat_per_kwu(sat_per_kwu: f32) -> Self {
+        FeeRate::new_checked(sat_per_kwu / 250.0_f32)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in sats/kvb
+    pub fn from_sat_per_kvb(sat_per_kvb: f32) -> Self {
+        FeeRate::new_checked(sat_per_kvb / 1000.0_f32)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in btc/kvbytes
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    pub fn from_btc_per_kvb(btc_per_kvb: f32) -> Self {
+        FeeRate::new_checked(btc_per_kvb * 1e5)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in satoshi/vbyte
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    pub fn from_sat_per_vb(sat_per_vb: f32) -> Self {
+        FeeRate::new_checked(sat_per_vb)
+    }
+
+    /// Create a new [`FeeRate`] with the default min relay fee value
+    pub const fn default_min_relay_fee() -> Self {
+        FeeRate(1.0)
+    }
+
+    /// Calculate fee rate from `fee` and weight units (`wu`).
+    pub fn from_wu(fee: u64, wu: Weight) -> FeeRate {
+        Self::from_vb(fee, wu.to_vbytes_ceil() as usize)
+    }
+
+    /// Calculate fee rate from `fee` and `vbytes`.
+    pub fn from_vb(fee: u64, vbytes: usize) -> FeeRate {
+        let rate = fee as f32 / vbytes as f32;
+        Self::from_sat_per_vb(rate)
+    }
+
+    /// Return the value as satoshi/vbyte
+    pub fn as_sat_per_vb(&self) -> f32 {
+        self.0
+    }
+
+    /// Return the value as satoshi/kwu
+    pub fn sat_per_kwu(&self) -> f32 {
+        self.0 * 250.0_f32
+    }
+
+    /// Calculate absolute fee in Satoshis using size in weight units.
+    pub fn fee_wu(&self, wu: Weight) -> u64 {
+        self.fee_vb(wu.to_vbytes_ceil() as usize)
+    }
+
+    /// Calculate absolute fee in Satoshis using size in virtual bytes.
+    pub fn fee_vb(&self, vbytes: usize) -> u64 {
+        (self.as_sat_per_vb() * vbytes as f32).ceil() as u64
+    }
+}
+
+impl Default for FeeRate {
+    fn default() -> Self {
+        FeeRate::default_min_relay_fee()
+    }
+}
+
+impl Sub for FeeRate {
+    type Output = Self;
+
+    fn sub(self, other: FeeRate) -> Self::Output {
+        FeeRate(self.0 - other.0)
+    }
+}
+
+/// Trait implemented by types that can be used to measure weight units.
+pub trait Vbytes {
+    /// Convert weight units to virtual bytes.
+    fn vbytes(self) -> usize;
+}
+
+impl Vbytes for usize {
+    fn vbytes(self) -> usize {
+        // ref: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-size-calculations
+        (self as f32 / 4.0).ceil() as usize
+    }
+}
+
 /// An unspent output owned by a [`Wallet`].
 ///
 /// [`Wallet`]: crate::Wallet
@@ -86,8 +197,6 @@ pub enum Utxo {
    Foreign {
        /// The location of the output.
        outpoint: OutPoint,
-        /// The nSequence value to set for this input.
-        sequence: Option<Sequence>,
        /// The information about the input we require to add it to a PSBT.
        // Box it to stop the type being too big.
        psbt_input: Box<psbt::Input>,
@@ -110,7 +219,6 @@ impl Utxo {
            Utxo::Foreign {
                outpoint,
                psbt_input,
-                ..
            } => {
                if let Some(prev_tx) = &psbt_input.non_witness_utxo {
                    return &prev_tx.output[outpoint.vout as usize];
@@ -124,12 +232,74 @@ impl Utxo {
            }
        }
    }
+}

-    /// Get the sequence number if an explicit sequence number has to be set for this input.
-    pub fn sequence(&self) -> Option<Sequence> {
-        match self {
-            Utxo::Local(_) => None,
-            Utxo::Foreign { sequence, .. } => *sequence,
-        }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn can_store_feerate_in_const() {
+        const _MIN_RELAY: FeeRate = FeeRate::default_min_relay_fee();
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_neg_zero() {
+        let _ = FeeRate::from_sat_per_vb(-0.0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_neg_value() {
+        let _ = FeeRate::from_sat_per_vb(-5.0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_nan() {
+        let _ = FeeRate::from_sat_per_vb(f32::NAN);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_inf() {
+        let _ = FeeRate::from_sat_per_vb(f32::INFINITY);
+    }
+
+    #[test]
+    fn test_valid_feerate_pos_zero() {
+        let _ = FeeRate::from_sat_per_vb(0.0);
+    }
+
+    #[test]
+    fn test_fee_from_btc_per_kvb() {
+        let fee = FeeRate::from_btc_per_kvb(1e-5);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_vbyte() {
+        let fee = FeeRate::from_sat_per_vb(1.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_default_min_relay_fee() {
+        let fee = FeeRate::default_min_relay_fee();
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_kvb() {
+        let fee = FeeRate::from_sat_per_kvb(1000.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_kwu() {
+        let fee = FeeRate::from_sat_per_kwu(250.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+        assert_eq!(fee.sat_per_kwu(), 250.0);
    }
 }
--- a/crates/bdk/src/wallet/coin_selection.rs
+++ b/crates/bdk/src/wallet/coin_selection.rs
@@ -32,6 +32,7 @@
 //! # use bdk::*;
 //! # use bdk::wallet::coin_selection::decide_change;
 //! # use anyhow::Error;
+//! # const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4) * 4;
 //! #[derive(Debug)]
 //! struct AlwaysSpendEverything;
 //!
@@ -40,7 +41,7 @@
 //!         &self,
 //!         required_utxos: Vec<WeightedUtxo>,
 //!         optional_utxos: Vec<WeightedUtxo>,
-//!         fee_rate: FeeRate,
+//!         fee_rate: bdk::FeeRate,
 //!         target_amount: u64,
 //!         drain_script: &Script,
 //!     ) -> Result<CoinSelectionResult, coin_selection::Error> {
@@ -52,17 +53,15 @@
 //!             .scan(
 //!                 (&mut selected_amount, &mut additional_weight),
 //!                 |(selected_amount, additional_weight), weighted_utxo| {
-//!                     **selected_amount += weighted_utxo.utxo.txout().value.to_sat();
+//!                     **selected_amount += weighted_utxo.utxo.txout().value;
 //!                     **additional_weight += Weight::from_wu(
-//!                         (TxIn::default().segwit_weight().to_wu()
-//!                             + weighted_utxo.satisfaction_weight as u64)
-//!                             as u64,
+//!                         (TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight) as u64,
 //!                     );
 //!                     Some(weighted_utxo.utxo)
 //!                 },
 //!             )
 //!             .collect::<Vec<_>>();
-//!         let additional_fees = (fee_rate * additional_weight).to_sat();
+//!         let additional_fees = fee_rate.fee_wu(additional_weight);
 //!         let amount_needed_with_fees = additional_fees + target_amount;
 //!         if selected_amount < amount_needed_with_fees {
 //!             return Err(coin_selection::Error::InsufficientFunds {
@@ -101,16 +100,13 @@
 //! # Ok::<(), anyhow::Error>(())
 //! ```

-use crate::chain::collections::HashSet;
+use crate::types::FeeRate;
 use crate::wallet::utils::IsDust;
 use crate::Utxo;
 use crate::WeightedUtxo;
-use bitcoin::FeeRate;

 use alloc::vec::Vec;
 use bitcoin::consensus::encode::serialize;
-use bitcoin::OutPoint;
-use bitcoin::TxIn;
 use bitcoin::{Script, Weight};

 use core::convert::TryInto;
@@ -121,6 +117,10 @@ use rand::seq::SliceRandom;
 /// overridden
 pub type DefaultCoinSelectionAlgorithm = BranchAndBoundCoinSelection;

+// Base weight of a Txin, not counting the weight needed for satisfying it.
+// prev_txid (32 bytes) + prev_vout (4 bytes) + sequence (4 bytes)
+pub(crate) const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4) * 4;
+
 /// Errors that can be thrown by the [`coin_selection`](crate::wallet::coin_selection) module
 #[derive(Debug)]
 pub enum Error {
@@ -193,7 +193,7 @@ pub struct CoinSelectionResult {
 impl CoinSelectionResult {
    /// The total value of the inputs selected.
    pub fn selected_amount(&self) -> u64 {
-        self.selected.iter().map(|u| u.txout().value.to_sat()).sum()
+        self.selected.iter().map(|u| u.txout().value).sum()
    }

    /// The total value of the inputs selected from the local wallet.
@@ -201,7 +201,7 @@ impl CoinSelectionResult {
        self.selected
            .iter()
            .filter_map(|u| match u {
-                Utxo::Local(_) => Some(u.txout().value.to_sat()),
+                Utxo::Local(_) => Some(u.txout().value),
                _ => None,
            })
            .sum()
@@ -311,8 +311,7 @@ impl CoinSelectionAlgorithm for OldestFirstCoinSelection {
 pub fn decide_change(remaining_amount: u64, fee_rate: FeeRate, drain_script: &Script) -> Excess {
    // drain_output_len = size(len(script_pubkey)) + len(script_pubkey) + size(output_value)
    let drain_output_len = serialize(drain_script).len() + 8usize;
-    let change_fee =
-        (fee_rate * Weight::from_vb(drain_output_len as u64).expect("overflow occurred")).to_sat();
+    let change_fee = fee_rate.fee_vb(drain_output_len);
    let drain_val = remaining_amount.saturating_sub(change_fee);

    if drain_val.is_dust(drain_script) {
@@ -343,13 +342,10 @@ fn select_sorted_utxos(
            (&mut selected_amount, &mut fee_amount),
            |(selected_amount, fee_amount), (must_use, weighted_utxo)| {
                if must_use || **selected_amount < target_amount + **fee_amount {
-                    **fee_amount += (fee_rate
-                        * Weight::from_wu(
-                            TxIn::default().segwit_weight().to_wu()
-                                + weighted_utxo.satisfaction_weight as u64,
-                        ))
-                    .to_sat();
-                    **selected_amount += weighted_utxo.utxo.txout().value.to_sat();
+                    **fee_amount += fee_rate.fee_wu(Weight::from_wu(
+                        (TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight) as u64,
+                    ));
+                    **selected_amount += weighted_utxo.utxo.txout().value;
                    Some(weighted_utxo.utxo)
                } else {
                    None
@@ -389,12 +385,10 @@ struct OutputGroup {

 impl OutputGroup {
    fn new(weighted_utxo: WeightedUtxo, fee_rate: FeeRate) -> Self {
-        let fee = (fee_rate
-            * Weight::from_wu(
-                TxIn::default().segwit_weight().to_wu() + weighted_utxo.satisfaction_weight as u64,
-            ))
-        .to_sat();
-        let effective_value = weighted_utxo.utxo.txout().value.to_sat() as i64 - fee as i64;
+        let fee = fee_rate.fee_wu(Weight::from_wu(
+            (TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight) as u64,
+        ));
+        let effective_value = weighted_utxo.utxo.txout().value as i64 - fee as i64;
        OutputGroup {
            weighted_utxo,
            fee,
@@ -460,8 +454,7 @@ impl CoinSelectionAlgorithm for BranchAndBoundCoinSelection {
            .iter()
            .fold(0, |acc, x| acc + x.effective_value);

-        let cost_of_change =
-            (Weight::from_vb(self.size_of_change).expect("overflow occurred") * fee_rate).to_sat();
+        let cost_of_change = self.size_of_change as f32 * fee_rate.as_sat_per_vb();

        // `curr_value` and `curr_available_value` are both the sum of *effective_values* of
        // the UTXOs. For the optional UTXOs (curr_available_value) we filter out UTXOs with
@@ -485,7 +478,7 @@ impl CoinSelectionAlgorithm for BranchAndBoundCoinSelection {
                    .chain(optional_utxos.iter())
                    .fold((0, 0), |(mut fees, mut value), utxo| {
                        fees += utxo.fee;
-                        value += utxo.weighted_utxo.utxo.txout().value.to_sat();
+                        value += utxo.weighted_utxo.utxo.txout().value;

                        (fees, value)
                    });
@@ -552,7 +545,7 @@ impl BranchAndBoundCoinSelection {
        mut curr_value: i64,
        mut curr_available_value: i64,
        target_amount: i64,
-        cost_of_change: u64,
+        cost_of_change: f32,
        drain_script: &Script,
        fee_rate: FeeRate,
    ) -> Result<CoinSelectionResult, Error> {
@@ -589,7 +582,7 @@ impl BranchAndBoundCoinSelection {
                // If we found a solution better than the previous one, or if there wasn't previous
                // solution, update the best solution
                if best_selection_value.is_none() || curr_value < best_selection_value.unwrap() {
-                    best_selection.clone_from(&current_selection);
+                    best_selection = current_selection.clone();
                    best_selection_value = Some(curr_value);
                }

@@ -718,44 +711,25 @@ impl BranchAndBoundCoinSelection {
    }
 }

-/// Remove duplicate UTXOs.
-///
-/// If a UTXO appears in both `required` and `optional`, the appearance in `required` is kept.
-pub(crate) fn filter_duplicates<I>(required: I, optional: I) -> (I, I)
-where
-    I: IntoIterator<Item = WeightedUtxo> + FromIterator<WeightedUtxo>,
-{
-    let mut visited = HashSet::<OutPoint>::new();
-    let required = required
-        .into_iter()
-        .filter(|utxo| visited.insert(utxo.utxo.outpoint()))
-        .collect::<I>();
-    let optional = optional
-        .into_iter()
-        .filter(|utxo| visited.insert(utxo.utxo.outpoint()))
-        .collect::<I>();
-    (required, optional)
-}
-
 #[cfg(test)]
 mod test {
    use assert_matches::assert_matches;
    use core::str::FromStr;

    use bdk_chain::ConfirmationTime;
-    use bitcoin::{Amount, ScriptBuf, TxIn, TxOut};
+    use bitcoin::{OutPoint, ScriptBuf, TxOut};

    use super::*;
    use crate::types::*;
-    use crate::wallet::coin_selection::filter_duplicates;
+    use crate::wallet::Vbytes;

    use rand::rngs::StdRng;
    use rand::seq::SliceRandom;
    use rand::{Rng, RngCore, SeedableRng};

-    // signature len (1WU) + signature and sighash (72WU)
-    // + pubkey len (1WU) + pubkey (33WU)
-    const P2WPKH_SATISFACTION_SIZE: usize = 1 + 72 + 1 + 33;
+    // n. of items on witness (1WU) + signature len (1WU) + signature and sighash (72WU)
+    // + pubkey len (1WU) + pubkey (33WU) + script sig len (1 byte, 4WU)
+    const P2WPKH_SATISFACTION_SIZE: usize = 1 + 1 + 72 + 1 + 33 + 4;

    const FEE_AMOUNT: u64 = 50;

@@ -771,7 +745,7 @@ mod test {
            utxo: Utxo::Local(LocalOutput {
                outpoint,
                txout: TxOut {
-                    value: Amount::from_sat(value),
+                    value,
                    script_pubkey: ScriptBuf::new(),
                },
                keychain: KeychainKind::External,
@@ -825,17 +799,16 @@ mod test {

    fn generate_random_utxos(rng: &mut StdRng, utxos_number: usize) -> Vec<WeightedUtxo> {
        let mut res = Vec::new();
-        for i in 0..utxos_number {
+        for _ in 0..utxos_number {
            res.push(WeightedUtxo {
                satisfaction_weight: P2WPKH_SATISFACTION_SIZE,
                utxo: Utxo::Local(LocalOutput {
-                    outpoint: OutPoint::from_str(&format!(
-                        "ebd9813ecebc57ff8f30797de7c205e3c7498ca950ea4341ee51a685ff2fa30a:{}",
-                        i
-                    ))
+                    outpoint: OutPoint::from_str(
+                        "ebd9813ecebc57ff8f30797de7c205e3c7498ca950ea4341ee51a685ff2fa30a:0",
+                    )
                    .unwrap(),
                    txout: TxOut {
-                        value: Amount::from_sat(rng.gen_range(0..200000000)),
+                        value: rng.gen_range(0..200000000),
                        script_pubkey: ScriptBuf::new(),
                    },
                    keychain: KeychainKind::External,
@@ -856,26 +829,24 @@ mod test {
    }

    fn generate_same_value_utxos(utxos_value: u64, utxos_number: usize) -> Vec<WeightedUtxo> {
-        (0..utxos_number)
-            .map(|i| WeightedUtxo {
-                satisfaction_weight: P2WPKH_SATISFACTION_SIZE,
-                utxo: Utxo::Local(LocalOutput {
-                    outpoint: OutPoint::from_str(&format!(
-                        "ebd9813ecebc57ff8f30797de7c205e3c7498ca950ea4341ee51a685ff2fa30a:{}",
-                        i
-                    ))
-                    .unwrap(),
-                    txout: TxOut {
-                        value: Amount::from_sat(utxos_value),
-                        script_pubkey: ScriptBuf::new(),
-                    },
-                    keychain: KeychainKind::External,
-                    is_spent: false,
-                    derivation_index: 42,
-                    confirmation_time: ConfirmationTime::Unconfirmed { last_seen: 0 },
-                }),
-            })
-            .collect()
+        let utxo = WeightedUtxo {
+            satisfaction_weight: P2WPKH_SATISFACTION_SIZE,
+            utxo: Utxo::Local(LocalOutput {
+                outpoint: OutPoint::from_str(
+                    "ebd9813ecebc57ff8f30797de7c205e3c7498ca950ea4341ee51a685ff2fa30a:0",
+                )
+                .unwrap(),
+                txout: TxOut {
+                    value: utxos_value,
+                    script_pubkey: ScriptBuf::new(),
+                },
+                keychain: KeychainKind::External,
+                is_spent: false,
+                derivation_index: 42,
+                confirmation_time: ConfirmationTime::Unconfirmed { last_seen: 0 },
+            }),
+        };
+        vec![utxo; utxos_number]
    }

    fn sum_random_utxos(mut rng: &mut StdRng, utxos: &mut Vec<WeightedUtxo>) -> u64 {
@@ -883,7 +854,7 @@ mod test {
        utxos.shuffle(&mut rng);
        utxos[..utxos_picked_len]
            .iter()
-            .map(|u| u.utxo.txout().value.to_sat())
+            .map(|u| u.utxo.txout().value)
            .sum()
    }

@@ -897,7 +868,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -918,7 +889,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -939,7 +910,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -961,7 +932,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -979,7 +950,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1000),
+                FeeRate::from_sat_per_vb(1000.0),
                target_amount,
                &drain_script,
            )
@@ -996,7 +967,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1017,7 +988,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1038,7 +1009,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1060,7 +1031,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1072,18 +1043,14 @@ mod test {
    fn test_oldest_first_coin_selection_insufficient_funds_high_fees() {
        let utxos = get_oldest_first_test_utxos();

-        let target_amount: u64 = utxos
-            .iter()
-            .map(|wu| wu.utxo.txout().value.to_sat())
-            .sum::<u64>()
-            - 50;
+        let target_amount: u64 = utxos.iter().map(|wu| wu.utxo.txout().value).sum::<u64>() - 50;
        let drain_script = ScriptBuf::default();

        OldestFirstCoinSelection
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1000),
+                FeeRate::from_sat_per_vb(1000.0),
                target_amount,
                &drain_script,
            )
@@ -1104,7 +1071,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1125,7 +1092,7 @@ mod test {
            .coin_select(
                utxos.clone(),
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1146,7 +1113,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1171,9 +1138,9 @@ mod test {
        ));

        // Defensive assertions, for sanity and in case someone changes the test utxos vector.
-        let amount: u64 = required.iter().map(|u| u.utxo.txout().value.to_sat()).sum();
+        let amount: u64 = required.iter().map(|u| u.utxo.txout().value).sum();
        assert_eq!(amount, 100_000);
-        let amount: u64 = optional.iter().map(|u| u.utxo.txout().value.to_sat()).sum();
+        let amount: u64 = optional.iter().map(|u| u.utxo.txout().value).sum();
        assert!(amount > 150_000);
        let drain_script = ScriptBuf::default();

@@ -1183,7 +1150,7 @@ mod test {
            .coin_select(
                required,
                optional,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1205,7 +1172,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1223,7 +1190,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1000),
+                FeeRate::from_sat_per_vb(1000.0),
                target_amount,
                &drain_script,
            )
@@ -1235,19 +1202,22 @@ mod test {
        let utxos = get_test_utxos();
        let drain_script = ScriptBuf::default();
        let target_amount = 99932; // first utxo's effective value
-        let feerate = FeeRate::BROADCAST_MIN;

        let result = BranchAndBoundCoinSelection::new(0)
-            .coin_select(vec![], utxos, feerate, target_amount, &drain_script)
+            .coin_select(
+                vec![],
+                utxos,
+                FeeRate::from_sat_per_vb(1.0),
+                target_amount,
+                &drain_script,
+            )
            .unwrap();

        assert_eq!(result.selected.len(), 1);
        assert_eq!(result.selected_amount(), 100_000);
-        let input_weight =
-            TxIn::default().segwit_weight().to_wu() + P2WPKH_SATISFACTION_SIZE as u64;
+        let input_size = (TXIN_BASE_WEIGHT + P2WPKH_SATISFACTION_SIZE).vbytes();
        // the final fee rate should be exactly the same as the fee rate given
-        let result_feerate = Amount::from_sat(result.fee_amount) / Weight::from_wu(input_weight);
-        assert_eq!(result_feerate, feerate);
+        assert!((1.0 - (result.fee_amount as f32 / input_size as f32)).abs() < f32::EPSILON);
    }

    #[test]
@@ -1263,7 +1233,7 @@ mod test {
                .coin_select(
                    vec![],
                    optional_utxos,
-                    FeeRate::ZERO,
+                    FeeRate::from_sat_per_vb(0.0),
                    target_amount,
                    &drain_script,
                )
@@ -1275,7 +1245,7 @@ mod test {
    #[test]
    #[should_panic(expected = "BnBNoExactMatch")]
    fn test_bnb_function_no_exact_match() {
-        let fee_rate = FeeRate::from_sat_per_vb_unchecked(10);
+        let fee_rate = FeeRate::from_sat_per_vb(10.0);
        let utxos: Vec<OutputGroup> = get_test_utxos()
            .into_iter()
            .map(|u| OutputGroup::new(u, fee_rate))
@@ -1284,7 +1254,7 @@ mod test {
        let curr_available_value = utxos.iter().fold(0, |acc, x| acc + x.effective_value);

        let size_of_change = 31;
-        let cost_of_change = (Weight::from_vb_unchecked(size_of_change) * fee_rate).to_sat();
+        let cost_of_change = size_of_change as f32 * fee_rate.as_sat_per_vb();

        let drain_script = ScriptBuf::default();
        let target_amount = 20_000 + FEE_AMOUNT;
@@ -1305,7 +1275,7 @@ mod test {
    #[test]
    #[should_panic(expected = "BnBTotalTriesExceeded")]
    fn test_bnb_function_tries_exceeded() {
-        let fee_rate = FeeRate::from_sat_per_vb_unchecked(10);
+        let fee_rate = FeeRate::from_sat_per_vb(10.0);
        let utxos: Vec<OutputGroup> = generate_same_value_utxos(100_000, 100_000)
            .into_iter()
            .map(|u| OutputGroup::new(u, fee_rate))
@@ -1314,7 +1284,7 @@ mod test {
        let curr_available_value = utxos.iter().fold(0, |acc, x| acc + x.effective_value);

        let size_of_change = 31;
-        let cost_of_change = (Weight::from_vb_unchecked(size_of_change) * fee_rate).to_sat();
+        let cost_of_change = size_of_change as f32 * fee_rate.as_sat_per_vb();
        let target_amount = 20_000 + FEE_AMOUNT;

        let drain_script = ScriptBuf::default();
@@ -1336,9 +1306,9 @@ mod test {
    // The match won't be exact but still in the range
    #[test]
    fn test_bnb_function_almost_exact_match_with_fees() {
-        let fee_rate = FeeRate::from_sat_per_vb_unchecked(1);
+        let fee_rate = FeeRate::from_sat_per_vb(1.0);
        let size_of_change = 31;
-        let cost_of_change = (Weight::from_vb_unchecked(size_of_change) * fee_rate).to_sat();
+        let cost_of_change = size_of_change as f32 * fee_rate.as_sat_per_vb();

        let utxos: Vec<_> = generate_same_value_utxos(50_000, 10)
            .into_iter()
@@ -1351,7 +1321,7 @@ mod test {

        // 2*(value of 1 utxo)  - 2*(1 utxo fees with 1.0sat/vbyte fee rate) -
        // cost_of_change + 5.
-        let target_amount = 2 * 50_000 - 2 * 67 - cost_of_change as i64 + 5;
+        let target_amount = 2 * 50_000 - 2 * 67 - cost_of_change.ceil() as i64 + 5;

        let drain_script = ScriptBuf::default();

@@ -1376,7 +1346,7 @@ mod test {
    fn test_bnb_function_exact_match_more_utxos() {
        let seed = [0; 32];
        let mut rng: StdRng = SeedableRng::from_seed(seed);
-        let fee_rate = FeeRate::ZERO;
+        let fee_rate = FeeRate::from_sat_per_vb(0.0);

        for _ in 0..200 {
            let optional_utxos: Vec<_> = generate_random_utxos(&mut rng, 40)
@@ -1402,7 +1372,7 @@ mod test {
                    curr_value,
                    curr_available_value,
                    target_amount,
-                    0,
+                    0.0,
                    &drain_script,
                    fee_rate,
                )
@@ -1418,7 +1388,7 @@ mod test {
        let mut utxos = generate_random_utxos(&mut rng, 300);
        let target_amount = sum_random_utxos(&mut rng, &mut utxos) + FEE_AMOUNT;

-        let fee_rate = FeeRate::from_sat_per_vb_unchecked(1);
+        let fee_rate = FeeRate::from_sat_per_vb(1.0);
        let utxos: Vec<OutputGroup> = utxos
            .into_iter()
            .map(|u| OutputGroup::new(u, fee_rate))
@@ -1447,7 +1417,7 @@ mod test {
        let selection = BranchAndBoundCoinSelection::default().coin_select(
            vec![],
            utxos,
-            FeeRate::from_sat_per_vb_unchecked(10),
+            FeeRate::from_sat_per_vb(10.0),
            500_000,
            &drain_script,
        );
@@ -1466,14 +1436,14 @@ mod test {
        let utxos = get_test_utxos();
        let drain_script = ScriptBuf::default();

-        let (required, optional) = utxos.into_iter().partition(
-            |u| matches!(u, WeightedUtxo { utxo, .. } if utxo.txout().value.to_sat() < 1000),
-        );
+        let (required, optional) = utxos
+            .into_iter()
+            .partition(|u| matches!(u, WeightedUtxo { utxo, .. } if utxo.txout().value < 1000));

        let selection = BranchAndBoundCoinSelection::default().coin_select(
            required,
            optional,
-            FeeRate::from_sat_per_vb_unchecked(10),
+            FeeRate::from_sat_per_vb(10.0),
            500_000,
            &drain_script,
        );
@@ -1495,7 +1465,7 @@ mod test {
        let selection = BranchAndBoundCoinSelection::default().coin_select(
            utxos,
            vec![],
-            FeeRate::from_sat_per_vb_unchecked(10_000),
+            FeeRate::from_sat_per_vb(10_000.0),
            500_000,
            &drain_script,
        );
@@ -1508,95 +1478,4 @@ mod test {
            })
        );
    }
-
-    #[test]
-    fn test_filter_duplicates() {
-        fn utxo(txid: &str, value: u64) -> WeightedUtxo {
-            WeightedUtxo {
-                satisfaction_weight: 0,
-                utxo: Utxo::Local(LocalOutput {
-                    outpoint: OutPoint::new(bitcoin::hashes::Hash::hash(txid.as_bytes()), 0),
-                    txout: TxOut {
-                        value: Amount::from_sat(value),
-                        script_pubkey: ScriptBuf::new(),
-                    },
-                    keychain: KeychainKind::External,
-                    is_spent: false,
-                    derivation_index: 0,
-                    confirmation_time: ConfirmationTime::Confirmed {
-                        height: 12345,
-                        time: 12345,
-                    },
-                }),
-            }
-        }
-
-        fn to_utxo_vec(utxos: &[(&str, u64)]) -> Vec<WeightedUtxo> {
-            let mut v = utxos
-                .iter()
-                .map(|&(txid, value)| utxo(txid, value))
-                .collect::<Vec<_>>();
-            v.sort_by_key(|u| u.utxo.outpoint());
-            v
-        }
-
-        struct TestCase<'a> {
-            name: &'a str,
-            required: &'a [(&'a str, u64)],
-            optional: &'a [(&'a str, u64)],
-            exp_required: &'a [(&'a str, u64)],
-            exp_optional: &'a [(&'a str, u64)],
-        }
-
-        let test_cases = [
-            TestCase {
-                name: "no_duplicates",
-                required: &[("A", 1000), ("B", 2100)],
-                optional: &[("C", 1000)],
-                exp_required: &[("A", 1000), ("B", 2100)],
-                exp_optional: &[("C", 1000)],
-            },
-            TestCase {
-                name: "duplicate_required_utxos",
-                required: &[("A", 3000), ("B", 1200), ("C", 1234), ("A", 3000)],
-                optional: &[("D", 2100)],
-                exp_required: &[("A", 3000), ("B", 1200), ("C", 1234)],
-                exp_optional: &[("D", 2100)],
-            },
-            TestCase {
-                name: "duplicate_optional_utxos",
-                required: &[("A", 3000), ("B", 1200)],
-                optional: &[("C", 5000), ("D", 1300), ("C", 5000)],
-                exp_required: &[("A", 3000), ("B", 1200)],
-                exp_optional: &[("C", 5000), ("D", 1300)],
-            },
-            TestCase {
-                name: "duplicate_across_required_and_optional_utxos",
-                required: &[("A", 3000), ("B", 1200), ("C", 2100)],
-                optional: &[("A", 3000), ("D", 1200), ("E", 5000)],
-                exp_required: &[("A", 3000), ("B", 1200), ("C", 2100)],
-                exp_optional: &[("D", 1200), ("E", 5000)],
-            },
-        ];
-
-        for (i, t) in test_cases.into_iter().enumerate() {
-            println!("Case {}: {}", i, t.name);
-            let (required, optional) =
-                filter_duplicates(to_utxo_vec(t.required), to_utxo_vec(t.optional));
-            assert_eq!(
-                required,
-                to_utxo_vec(t.exp_required),
-                "[{}:{}] unexpected `required` result",
-                i,
-                t.name
-            );
-            assert_eq!(
-                optional,
-                to_utxo_vec(t.exp_optional),
-                "[{}:{}] unexpected `optional` result",
-                i,
-                t.name
-            );
-        }
-    }
 }
--- a/crates/bdk/src/wallet/error.rs
+++ b/crates/bdk/src/wallet/error.rs
@@ -14,7 +14,7 @@
 use crate::descriptor::policy::PolicyError;
 use crate::descriptor::DescriptorError;
 use crate::wallet::coin_selection;
-use crate::{descriptor, KeychainKind};
+use crate::{descriptor, FeeRate, KeychainKind};
 use alloc::string::String;
 use bitcoin::{absolute, psbt, OutPoint, Sequence, Txid};
 use core::fmt;
@@ -83,8 +83,8 @@ pub enum CreateTxError<P> {
    },
    /// When bumping a tx the fee rate requested is lower than required
    FeeRateTooLow {
-        /// Required fee rate
-        required: bitcoin::FeeRate,
+        /// Required fee rate (satoshi/vbyte)
+        required: FeeRate,
    },
    /// `manually_selected_only` option is selected but no utxo has been passed
    NoUtxosSelected,
@@ -168,10 +168,8 @@ where
            CreateTxError::FeeRateTooLow { required } => {
                write!(
                    f,
-                    // Note: alternate fmt as sat/vb (ceil) available in bitcoin-0.31
-                    //"Fee rate too low: required {required:#}"
-                    "Fee rate too low: required {} sat/vb",
-                    crate::floating_rate!(required)
+                    "Fee rate too low: required {} sat/vbyte",
+                    required.as_sat_per_vb()
                )
            }
            CreateTxError::NoUtxosSelected => {
--- a/crates/bdk/src/wallet/export.rs
+++ b/crates/bdk/src/wallet/export.rs
@@ -216,7 +216,7 @@ mod test {

    use bdk_chain::{BlockId, ConfirmationTime};
    use bitcoin::hashes::Hash;
-    use bitcoin::{transaction, BlockHash, Network, Transaction};
+    use bitcoin::{BlockHash, Network, Transaction};

    use super::*;
    use crate::wallet::Wallet;
@@ -230,7 +230,7 @@ mod test {
        let transaction = Transaction {
            input: vec![],
            output: vec![],
-            version: transaction::Version::non_standard(0),
+            version: 0,
            lock_time: bitcoin::absolute::LockTime::ZERO,
        };
        wallet
--- a/crates/bdk/src/wallet/hardwaresigner.rs
+++ b/crates/bdk/src/wallet/hardwaresigner.rs
@@ -18,7 +18,7 @@
 //! # use bdk::signer::SignerOrdering;
 //! # use bdk::wallet::hardwaresigner::HWISigner;
 //! # use bdk::wallet::AddressIndex::New;
-//! # use bdk::{KeychainKind, SignOptions, Wallet};
+//! # use bdk::{FeeRate, KeychainKind, SignOptions, Wallet};
 //! # use hwi::HWIClient;
 //! # use std::sync::Arc;
 //! #
@@ -48,8 +48,8 @@
 //! ```

 use bitcoin::bip32::Fingerprint;
+use bitcoin::psbt::PartiallySignedTransaction;
 use bitcoin::secp256k1::{All, Secp256k1};
-use bitcoin::Psbt;

 use hwi::error::Error;
 use hwi::types::{HWIChain, HWIDevice};
@@ -87,7 +87,7 @@ impl SignerCommon for HWISigner {
 impl TransactionSigner for HWISigner {
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut PartiallySignedTransaction,
        _sign_options: &crate::SignOptions,
        _secp: &crate::wallet::utils::SecpCtx,
    ) -> Result<(), SignerError> {
--- a/crates/bdk/src/wallet/mod.rs
+++ b/crates/bdk/src/wallet/mod.rs
@@ -11,8 +11,8 @@

 //! Wallet
 //!
-//! This module defines the [`Wallet`].
-use crate::collections::{BTreeMap, HashMap};
+//! This module defines the [`Wallet`] structure.
+use crate::collections::{BTreeMap, HashMap, HashSet};
 use alloc::{
    boxed::Box,
    string::{String, ToString},
@@ -23,21 +23,19 @@ pub use bdk_chain::keychain::Balance;
 use bdk_chain::{
    indexed_tx_graph,
    keychain::{self, KeychainTxOutIndex},
-    local_chain::{
-        self, ApplyHeaderError, CannotConnectError, CheckPoint, CheckPointIter, LocalChain,
-    },
+    local_chain::{self, CannotConnectError, CheckPoint, CheckPointIter, LocalChain},
    tx_graph::{CanonicalTx, TxGraph},
    Append, BlockId, ChainPosition, ConfirmationTime, ConfirmationTimeHeightAnchor, FullTxOut,
    IndexedTxGraph, Persist, PersistBackend,
 };
-use bitcoin::constants::genesis_block;
 use bitcoin::secp256k1::{All, Secp256k1};
 use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::{
-    absolute, psbt, Address, Block, FeeRate, Network, OutPoint, Script, ScriptBuf, Sequence,
-    Transaction, TxOut, Txid, Witness,
+    absolute, Address, Network, OutPoint, Script, ScriptBuf, Sequence, Transaction, TxOut, Txid,
+    Weight, Witness,
 };
-use bitcoin::{consensus::encode::serialize, transaction, Amount, BlockHash, Psbt};
+use bitcoin::{consensus::encode::serialize, BlockHash};
+use bitcoin::{constants::genesis_block, psbt};
 use core::fmt;
 use core::ops::Deref;
 use descriptor::error::Error as DescriptorError;
@@ -52,8 +50,13 @@ pub mod tx_builder;
 pub(crate) mod utils;

 pub mod error;
+#[cfg(feature = "hardware-signer")]
+#[cfg_attr(docsrs, doc(cfg(feature = "hardware-signer")))]
+pub mod hardwaresigner;
+
 pub use utils::IsDust;

+#[allow(deprecated)]
 use coin_selection::DefaultCoinSelectionAlgorithm;
 use signer::{SignOptions, SignerOrdering, SignersContainer, TransactionSigner};
 use tx_builder::{BumpFee, CreateTx, FeePolicy, TxBuilder, TxParams};
@@ -74,7 +77,7 @@ const COINBASE_MATURITY: u32 = 100;

 /// A Bitcoin wallet
 ///
-/// The `Wallet` acts as a way of coherently interfacing with output descriptors and related transactions.
+/// The `Wallet` struct acts as a way of coherently interfacing with output descriptors and related transactions.
 /// Its main components are:
 ///
 /// 1. output *descriptors* from which it can derive addresses.
@@ -234,7 +237,6 @@ impl Wallet {
        network: Network,
    ) -> Result<Self, DescriptorError> {
        Self::new(descriptor, change_descriptor, (), network).map_err(|e| match e {
-            NewError::NonEmptyDatabase => unreachable!("mock-database cannot have data"),
            NewError::Descriptor(e) => e,
            NewError::Write(_) => unreachable!("mock-write must always succeed"),
        })
@@ -249,7 +251,6 @@ impl Wallet {
    ) -> Result<Self, crate::descriptor::DescriptorError> {
        Self::new_with_genesis_hash(descriptor, change_descriptor, (), network, genesis_hash)
            .map_err(|e| match e {
-                NewError::NonEmptyDatabase => unreachable!("mock-database cannot have data"),
                NewError::Descriptor(e) => e,
                NewError::Write(_) => unreachable!("mock-write must always succeed"),
            })
@@ -263,11 +264,6 @@ where
    /// Infallibly return a derived address using the external descriptor, see [`AddressIndex`] for
    /// available address index selection strategies. If none of the keys in the descriptor are derivable
    /// (i.e. does not end with /*) then the same address will always be returned for any [`AddressIndex`].
-    ///
-    /// # Panics
-    ///
-    /// This panics when the caller requests for an address of derivation index greater than the
-    /// BIP32 max index.
    pub fn get_address(&mut self, address_index: AddressIndex) -> AddressInfo {
        self.try_get_address(address_index).unwrap()
    }
@@ -279,11 +275,6 @@ where
    /// see [`AddressIndex`] for available address index selection strategies. If none of the keys
    /// in the descriptor are derivable (i.e. does not end with /*) then the same address will always
    /// be returned for any [`AddressIndex`].
-    ///
-    /// # Panics
-    ///
-    /// This panics when the caller requests for an address of derivation index greater than the
-    /// BIP32 max index.
    pub fn get_internal_address(&mut self, address_index: AddressIndex) -> AddressInfo {
        self.try_get_internal_address(address_index).unwrap()
    }
@@ -297,8 +288,6 @@ where
 /// [`new_with_genesis_hash`]: Wallet::new_with_genesis_hash
 #[derive(Debug)]
 pub enum NewError<W> {
-    /// Database already has data.
-    NonEmptyDatabase,
    /// There was problem with the passed-in descriptor(s).
    Descriptor(crate::descriptor::DescriptorError),
    /// We were unable to write the wallet's data to the persistence backend.
@@ -311,10 +300,6 @@ where
 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            NewError::NonEmptyDatabase => write!(
-                f,
-                "database already has data - use `load` or `new_or_load` methods instead"
-            ),
            NewError::Descriptor(e) => e.fmt(f),
            NewError::Write(e) => e.fmt(f),
        }
@@ -363,7 +348,7 @@ where
 #[cfg(feature = "std")]
 impl<L> std::error::Error for LoadError<L> where L: core::fmt::Display + core::fmt::Debug {}

-/// Error type for when we try load a [`Wallet`] from persistence and creating it if non-existent.
+/// Error type for when we try load a [`Wallet`] from persistence and creating it if non-existant.
 ///
 /// Methods [`new_or_load`] and [`new_or_load_with_genesis_hash`] may return this error.
 ///
@@ -439,55 +424,6 @@ pub enum InsertTxError {
    },
 }

-impl fmt::Display for InsertTxError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            InsertTxError::ConfirmationHeightCannotBeGreaterThanTip {
-                tip_height,
-                tx_height,
-            } => {
-                write!(f, "cannot insert tx with confirmation height ({}) higher than internal tip height ({})", tx_height, tip_height)
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for InsertTxError {}
-
-/// An error that may occur when applying a block to [`Wallet`].
-#[derive(Debug)]
-pub enum ApplyBlockError {
-    /// Occurs when the update chain cannot connect with original chain.
-    CannotConnect(CannotConnectError),
-    /// Occurs when the `connected_to` hash does not match the hash derived from `block`.
-    UnexpectedConnectedToHash {
-        /// Block hash of `connected_to`.
-        connected_to_hash: BlockHash,
-        /// Expected block hash of `connected_to`, as derived from `block`.
-        expected_hash: BlockHash,
-    },
-}
-
-impl fmt::Display for ApplyBlockError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ApplyBlockError::CannotConnect(err) => err.fmt(f),
-            ApplyBlockError::UnexpectedConnectedToHash {
-                expected_hash: block_hash,
-                connected_to_hash: checkpoint_hash,
-            } => write!(
-                f,
-                "`connected_to` hash {} differs from the expected hash {} (which is derived from `block`)",
-                checkpoint_hash, block_hash
-            ),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ApplyBlockError {}
-
 impl<D> Wallet<D> {
    /// Initialize an empty [`Wallet`].
    pub fn new<E: IntoWalletDescriptor>(
@@ -510,18 +446,13 @@ impl<D> Wallet<D> {
    pub fn new_with_genesis_hash<E: IntoWalletDescriptor>(
        descriptor: E,
        change_descriptor: Option<E>,
-        mut db: D,
+        db: D,
        network: Network,
        genesis_hash: BlockHash,
    ) -> Result<Self, NewError<D::WriteError>>
    where
        D: PersistBackend<ChangeSet>,
    {
-        if let Ok(changeset) = db.load_from_persistence() {
-            if changeset.is_some() {
-                return Err(NewError::NonEmptyDatabase);
-            }
-        }
        let secp = Secp256k1::new();
        let (chain, chain_changeset) = LocalChain::from_genesis_hash(genesis_hash);
        let mut index = KeychainTxOutIndex::<KeychainKind>::default();
@@ -586,9 +517,7 @@ impl<D> Wallet<D> {
            create_signers(&mut index, &secp, descriptor, change_descriptor, network)
                .map_err(LoadError::Descriptor)?;

-        let mut indexed_graph = IndexedTxGraph::new(index);
-        indexed_graph.apply_changeset(changeset.indexed_tx_graph);
-
+        let indexed_graph = IndexedTxGraph::new(index);
        let persist = Persist::new(db);

        Ok(Wallet {
@@ -684,9 +613,6 @@ impl<D> Wallet<D> {
                genesis_hash,
            )
            .map_err(|e| match e {
-                NewError::NonEmptyDatabase => {
-                    unreachable!("database is already checked to have no data")
-                }
                NewError::Descriptor(e) => NewOrLoadError::Descriptor(e),
                NewError::Write(e) => NewOrLoadError::Write(e),
            }),
@@ -709,11 +635,6 @@ impl<D> Wallet<D> {
    ///
    /// A `PersistBackend<ChangeSet>::WriteError` will result if unable to persist the new address
    /// to the `PersistBackend`.
-    ///
-    /// # Panics
-    ///
-    /// This panics when the caller requests for an address of derivation index greater than the
-    /// BIP32 max index.
    pub fn try_get_address(
        &mut self,
        address_index: AddressIndex,
@@ -734,11 +655,6 @@ impl<D> Wallet<D> {
    /// see [`AddressIndex`] for available address index selection strategies. If none of the keys
    /// in the descriptor are derivable (i.e. does not end with /*) then the same address will always
    /// be returned for any [`AddressIndex`].
-    ///
-    /// # Panics
-    ///
-    /// This panics when the caller requests for an address of derivation index greater than the
-    /// BIP32 max index.
    pub fn try_get_internal_address(
        &mut self,
        address_index: AddressIndex,
@@ -761,11 +677,6 @@ impl<D> Wallet<D> {
    /// See [`AddressIndex`] for available address index selection strategies. If none of the keys
    /// in the descriptor are derivable (i.e. does not end with /*) then the same address will
    /// always be returned for any [`AddressIndex`].
-    ///
-    /// # Panics
-    ///
-    /// This panics when the caller requests for an address of derivation index greater than the
-    /// BIP32 max index.
    fn _get_address(
        &mut self,
        keychain: KeychainKind,
@@ -785,14 +696,12 @@ impl<D> Wallet<D> {
                let ((index, spk), index_changeset) = txout_index.next_unused_spk(&keychain);
                (index, spk.into(), Some(index_changeset))
            }
-            AddressIndex::Peek(mut peek_index) => {
-                let mut spk_iter = txout_index.unbounded_spk_iter(&keychain);
-                if !spk_iter.descriptor().has_wildcard() {
-                    peek_index = 0;
-                }
-                let (index, spk) = spk_iter
-                    .nth(peek_index as usize)
-                    .expect("derivation index is out of bounds");
+            AddressIndex::Peek(index) => {
+                let (index, spk) = txout_index
+                    .spks_of_keychain(&keychain)
+                    .take(index as usize + 1)
+                    .last()
+                    .unwrap();
                (index, spk, None)
            }
        };
@@ -822,7 +731,7 @@ impl<D> Wallet<D> {
    ///
    /// Will only return `Some(_)` if the wallet has given out the spk.
    pub fn derivation_of_spk(&self, spk: &Script) -> Option<(KeychainKind, u32)> {
-        self.indexed_graph.index.index_of_spk(spk)
+        self.indexed_graph.index.index_of_spk(spk).copied()
    }

    /// Return the list of unspent outputs of this wallet
@@ -861,7 +770,7 @@ impl<D> Wallet<D> {
        self.chain.tip()
    }

-    /// Get unbounded script pubkey iterators for both `Internal` and `External` keychains.
+    /// Returns a iterators of all the script pubkeys for the `Internal` and External` variants in `KeychainKind`.
    ///
    /// This is intended to be used when doing a full scan of your addresses (e.g. after restoring
    /// from seed words). You pass the `BTreeMap` of iterators to a blockchain data source (e.g.
@@ -869,36 +778,36 @@ impl<D> Wallet<D> {
    ///
    /// Note carefully that iterators go over **all** script pubkeys on the keychains (not what
    /// script pubkeys the wallet is storing internally).
-    pub fn all_unbounded_spk_iters(
+    pub fn spks_of_all_keychains(
        &self,
    ) -> BTreeMap<KeychainKind, impl Iterator<Item = (u32, ScriptBuf)> + Clone> {
-        self.indexed_graph.index.all_unbounded_spk_iters()
+        self.indexed_graph.index.spks_of_all_keychains()
    }

-    /// Get an unbounded script pubkey iterator for the given `keychain`.
+    /// Gets an iterator over all the script pubkeys in a single keychain.
    ///
-    /// See [`all_unbounded_spk_iters`] for more documentation
+    /// See [`spks_of_all_keychains`] for more documentation
    ///
-    /// [`all_unbounded_spk_iters`]: Self::all_unbounded_spk_iters
-    pub fn unbounded_spk_iter(
+    /// [`spks_of_all_keychains`]: Self::spks_of_all_keychains
+    pub fn spks_of_keychain(
        &self,
        keychain: KeychainKind,
    ) -> impl Iterator<Item = (u32, ScriptBuf)> + Clone {
-        self.indexed_graph.index.unbounded_spk_iter(&keychain)
+        self.indexed_graph.index.spks_of_keychain(&keychain)
    }

    /// Returns the utxo owned by this wallet corresponding to `outpoint` if it exists in the
    /// wallet's database.
    pub fn get_utxo(&self, op: OutPoint) -> Option<LocalOutput> {
-        let (keychain, index, _) = self.indexed_graph.index.txout(op)?;
+        let (&spk_i, _) = self.indexed_graph.index.txout(op)?;
        self.indexed_graph
            .graph()
            .filter_chain_unspents(
                &self.chain,
                self.chain.tip().block_id(),
-                core::iter::once(((), op)),
+                core::iter::once((spk_i, op)),
            )
-            .map(|(_, full_txo)| new_local_utxo(keychain, index, full_txo))
+            .map(|((k, i), full_txo)| new_local_utxo(k, i, full_txo))
            .next()
    }

@@ -941,15 +850,15 @@ impl<D> Wallet<D> {
    /// # let mut wallet: Wallet<()> = todo!();
    /// # let txid:Txid = todo!();
    /// let tx = wallet.get_tx(txid).expect("transaction").tx_node.tx;
-    /// let fee = wallet.calculate_fee(&tx).expect("fee");
+    /// let fee = wallet.calculate_fee(tx).expect("fee");
    /// ```
    ///
    /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use bitcoin::psbt::PartiallySignedTransaction;
    /// # use bdk::Wallet;
    /// # let mut wallet: Wallet<()> = todo!();
-    /// # let mut psbt: Psbt = todo!();
-    /// let tx = &psbt.clone().extract_tx().expect("tx");
+    /// # let mut psbt: PartiallySignedTransaction = todo!();
+    /// let tx = &psbt.clone().extract_tx();
    /// let fee = wallet.calculate_fee(tx).expect("fee");
    /// ```
    /// [`insert_txout`]: Self::insert_txout
@@ -972,28 +881,31 @@ impl<D> Wallet<D> {
    /// # let mut wallet: Wallet<()> = todo!();
    /// # let txid:Txid = todo!();
    /// let tx = wallet.get_tx(txid).expect("transaction").tx_node.tx;
-    /// let fee_rate = wallet.calculate_fee_rate(&tx).expect("fee rate");
+    /// let fee_rate = wallet.calculate_fee_rate(tx).expect("fee rate");
    /// ```
    ///
    /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use bitcoin::psbt::PartiallySignedTransaction;
    /// # use bdk::Wallet;
    /// # let mut wallet: Wallet<()> = todo!();
-    /// # let mut psbt: Psbt = todo!();
-    /// let tx = &psbt.clone().extract_tx().expect("tx");
+    /// # let mut psbt: PartiallySignedTransaction = todo!();
+    /// let tx = &psbt.clone().extract_tx();
    /// let fee_rate = wallet.calculate_fee_rate(tx).expect("fee rate");
    /// ```
    /// [`insert_txout`]: Self::insert_txout
    pub fn calculate_fee_rate(&self, tx: &Transaction) -> Result<FeeRate, CalculateFeeError> {
-        self.calculate_fee(tx)
-            .map(|fee| bitcoin::Amount::from_sat(fee) / tx.weight())
+        self.calculate_fee(tx).map(|fee| {
+            let weight = tx.weight();
+            FeeRate::from_wu(fee, weight)
+        })
    }

-    /// Compute the `tx`'s sent and received amounts (in satoshis).
+    /// Computes total input value going from script pubkeys in the index (sent) and the total output
+    /// value going to script pubkeys in the index (received) in `tx`.
    ///
-    /// This method returns a tuple `(sent, received)`. Sent is the sum of the txin amounts
-    /// that spend from previous txouts tracked by this wallet. Received is the summation
-    /// of this tx's outputs that send to script pubkeys tracked by this wallet.
+    /// For the `sent` to be computed correctly, the outputs being spent must have already been
+    /// scanned by the index. Calculating received just uses the [`Transaction`] outputs directly,
+    /// so it will be correct even if it has not been scanned.
    ///
    /// # Examples
    ///
@@ -1002,16 +914,16 @@ impl<D> Wallet<D> {
    /// # use bdk::Wallet;
    /// # let mut wallet: Wallet<()> = todo!();
    /// # let txid:Txid = todo!();
-    /// let tx = wallet.get_tx(txid).expect("tx exists").tx_node.tx;
-    /// let (sent, received) = wallet.sent_and_received(&tx);
+    /// let tx = wallet.get_tx(txid).expect("transaction").tx_node.tx;
+    /// let (sent, received) = wallet.sent_and_received(tx);
    /// ```
    ///
    /// ```rust, no_run
-    /// # use bitcoin::Psbt;
+    /// # use bitcoin::psbt::PartiallySignedTransaction;
    /// # use bdk::Wallet;
    /// # let mut wallet: Wallet<()> = todo!();
-    /// # let mut psbt: Psbt = todo!();
-    /// let tx = &psbt.clone().extract_tx().expect("tx");
+    /// # let mut psbt: PartiallySignedTransaction = todo!();
+    /// let tx = &psbt.clone().extract_tx();
    /// let (sent, received) = wallet.sent_and_received(tx);
    /// ```
    pub fn sent_and_received(&self, tx: &Transaction) -> (u64, u64) {
@@ -1064,7 +976,7 @@ impl<D> Wallet<D> {
    pub fn get_tx(
        &self,
        txid: Txid,
-    ) -> Option<CanonicalTx<'_, Arc<Transaction>, ConfirmationTimeHeightAnchor>> {
+    ) -> Option<CanonicalTx<'_, Transaction, ConfirmationTimeHeightAnchor>> {
        let graph = self.indexed_graph.graph();

        Some(CanonicalTx {
@@ -1127,14 +1039,18 @@ impl<D> Wallet<D> {
                // anchor tx to checkpoint with lowest height that is >= position's height
                let anchor = self
                    .chain
+                    .blocks()
                    .range(height..)
-                    .last()
+                    .next()
                    .ok_or(InsertTxError::ConfirmationHeightCannotBeGreaterThanTip {
                        tip_height: self.chain.tip().height(),
                        tx_height: height,
                    })
-                    .map(|anchor_cp| ConfirmationTimeHeightAnchor {
-                        anchor_block: anchor_cp.block_id(),
+                    .map(|(&anchor_height, &hash)| ConfirmationTimeHeightAnchor {
+                        anchor_block: BlockId {
+                            height: anchor_height,
+                            hash,
+                        },
                        confirmation_height: height,
                        confirmation_time: time,
                    })?;
@@ -1162,8 +1078,7 @@ impl<D> Wallet<D> {
    /// Iterate over the transactions in the wallet.
    pub fn transactions(
        &self,
-    ) -> impl Iterator<Item = CanonicalTx<'_, Arc<Transaction>, ConfirmationTimeHeightAnchor>> + '_
-    {
+    ) -> impl Iterator<Item = CanonicalTx<'_, Transaction, ConfirmationTimeHeightAnchor>> + '_ {
        self.indexed_graph
            .graph()
            .list_chain_txs(&self.chain, self.chain.tip().block_id())
@@ -1261,7 +1176,7 @@ impl<D> Wallet<D> {
        &mut self,
        coin_selection: Cs,
        params: TxParams,
-    ) -> Result<Psbt, CreateTxError<D::WriteError>>
+    ) -> Result<psbt::PartiallySignedTransaction, CreateTxError<D::WriteError>>
    where
        D: PersistBackend<ChangeSet>,
    {
@@ -1341,7 +1256,7 @@ impl<D> Wallet<D> {
            }
            Some(tx_builder::Version(x)) => x,
            None if requirements.csv.is_some() => 2,
-            None => 1,
+            _ => 1,
        };

        // We use a match here instead of a unwrap_or_else as it's way more readable :)
@@ -1394,7 +1309,6 @@ impl<D> Wallet<D> {
            }
        };

-        // The nSequence to be by default for inputs unless an explicit sequence is specified.
        let n_sequence = match (params.rbf, requirements.csv) {
            // No RBF or CSV but there's an nLockTime, so the nSequence cannot be final
            (None, None) if lock_time != absolute::LockTime::ZERO => {
@@ -1426,36 +1340,37 @@ impl<D> Wallet<D> {
            (Some(rbf), _) => rbf.get_value(),
        };

-        let (fee_rate, mut fee_amount) = match params.fee_policy.unwrap_or_default() {
+        let (fee_rate, mut fee_amount) = match params
+            .fee_policy
+            .as_ref()
+            .unwrap_or(&FeePolicy::FeeRate(FeeRate::default()))
+        {
            //FIXME: see https://github.com/bitcoindevkit/bdk/issues/256
            FeePolicy::FeeAmount(fee) => {
                if let Some(previous_fee) = params.bumping_fee {
-                    if fee < previous_fee.absolute {
+                    if *fee < previous_fee.absolute {
                        return Err(CreateTxError::FeeTooLow {
                            required: previous_fee.absolute,
                        });
                    }
                }
-                (FeeRate::ZERO, fee)
+                (FeeRate::from_sat_per_vb(0.0), *fee)
            }
            FeePolicy::FeeRate(rate) => {
                if let Some(previous_fee) = params.bumping_fee {
-                    let required_feerate = FeeRate::from_sat_per_kwu(
-                        previous_fee.rate.to_sat_per_kwu()
-                            + FeeRate::BROADCAST_MIN.to_sat_per_kwu(), // +1 sat/vb
-                    );
-                    if rate < required_feerate {
+                    let required_feerate = FeeRate::from_sat_per_vb(previous_fee.rate + 1.0);
+                    if *rate < required_feerate {
                        return Err(CreateTxError::FeeRateTooLow {
                            required: required_feerate,
                        });
                    }
                }
-                (rate, 0)
+                (*rate, 0)
            }
        };

        let mut tx = Transaction {
-            version: transaction::Version::non_standard(version),
+            version,
            lock_time,
            input: vec![],
            output: vec![],
@@ -1485,7 +1400,7 @@ impl<D> Wallet<D> {

            let new_out = TxOut {
                script_pubkey: script_pubkey.clone(),
-                value: Amount::from_sat(value),
+                value,
            };

            tx.output.push(new_out);
@@ -1493,7 +1408,18 @@ impl<D> Wallet<D> {
            outgoing += value;
        }

-        fee_amount += (fee_rate * tx.weight()).to_sat();
+        fee_amount += fee_rate.fee_wu(tx.weight());
+
+        // Segwit transactions' header is 2WU larger than legacy txs' header,
+        // as they contain a witness marker (1WU) and a witness flag (1WU) (see BIP144).
+        // At this point we really don't know if the resulting transaction will be segwit
+        // or legacy, so we just add this 2WU to the fee_amount - overshooting the fee amount
+        // is better than undershooting it.
+        // If we pass a fee_amount that is slightly higher than the final fee_amount, we
+        // end up with a transaction with a slightly higher fee rate than the requested one.
+        // If, instead, we undershoot, we may end up with a feerate lower than the requested one
+        // - we might come up with non broadcastable txs!
+        fee_amount += fee_rate.fee_wu(Weight::from_wu(2));

        if params.change_policy != tx_builder::ChangeSpendPolicy::ChangeAllowed
            && internal_descriptor.is_none()
@@ -1501,8 +1427,15 @@ impl<D> Wallet<D> {
            return Err(CreateTxError::ChangePolicyDescriptor);
        }

-        let (required_utxos, optional_utxos) =
-            self.preselect_utxos(&params, Some(current_height.to_consensus_u32()));
+        let (required_utxos, optional_utxos) = self.preselect_utxos(
+            params.change_policy,
+            &params.unspendable,
+            params.utxos.clone(),
+            params.drain_wallet,
+            params.manually_selected_only,
+            params.bumping_fee.is_some(), // we mandate confirmed transactions if we're bumping the fee
+            Some(current_height.to_consensus_u32()),
+        );

        // get drain script
        let drain_script = match params.drain_to {
@@ -1512,7 +1445,7 @@ impl<D> Wallet<D> {
                let ((index, spk), index_changeset) =
                    self.indexed_graph.index.next_unused_spk(&change_keychain);
                let spk = spk.into();
-                self.indexed_graph.index.mark_used(change_keychain, index);
+                self.indexed_graph.index.mark_used(&change_keychain, index);
                self.persist
                    .stage(ChangeSet::from(indexed_tx_graph::ChangeSet::from(
                        index_changeset,
@@ -1522,9 +1455,6 @@ impl<D> Wallet<D> {
            }
        };

-        let (required_utxos, optional_utxos) =
-            coin_selection::filter_duplicates(required_utxos, optional_utxos);
-
        let coin_selection = coin_selection.coin_select(
            required_utxos,
            optional_utxos,
@@ -1541,7 +1471,7 @@ impl<D> Wallet<D> {
            .map(|u| bitcoin::TxIn {
                previous_output: u.outpoint(),
                script_sig: ScriptBuf::default(),
-                sequence: u.sequence().unwrap_or(n_sequence),
+                sequence: n_sequence,
                witness: Witness::new(),
            })
            .collect();
@@ -1583,7 +1513,7 @@ impl<D> Wallet<D> {

                // create drain output
                let drain_output = TxOut {
-                    value: Amount::from_sat(*amount),
+                    value: *amount,
                    script_pubkey: drain_script,
                };

@@ -1629,12 +1559,12 @@ impl<D> Wallet<D> {
    ///     builder.finish()?
    /// };
    /// let _ = wallet.sign(&mut psbt, SignOptions::default())?;
-    /// let tx = psbt.clone().extract_tx().expect("tx");
+    /// let tx = psbt.extract_tx();
    /// // broadcast tx but it's taking too long to confirm so we want to bump the fee
    /// let mut psbt =  {
    ///     let mut builder = wallet.build_fee_bump(tx.txid())?;
    ///     builder
-    ///         .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"));
+    ///         .fee_rate(bdk::FeeRate::from_sat_per_vb(5.0));
    ///     builder.finish()?
    /// };
    ///
@@ -1655,7 +1585,6 @@ impl<D> Wallet<D> {
        let mut tx = graph
            .get_tx(txid)
            .ok_or(BuildFeeBumpError::TransactionNotFound(txid))?
-            .as_ref()
            .clone();

        let pos = graph
@@ -1697,10 +1626,11 @@ impl<D> Wallet<D> {
                    .into();

                let weighted_utxo = match txout_index.index_of_spk(&txout.script_pubkey) {
-                    Some((keychain, derivation_index)) => {
+                    Some(&(keychain, derivation_index)) => {
+                        #[allow(deprecated)]
                        let satisfaction_weight = self
                            .get_descriptor_for_keychain(keychain)
-                            .max_weight_to_satisfy()
+                            .max_satisfaction_weight()
                            .unwrap();
                        WeightedUtxo {
                            utxo: Utxo::Local(LocalOutput {
@@ -1718,16 +1648,15 @@ impl<D> Wallet<D> {
                        let satisfaction_weight =
                            serialize(&txin.script_sig).len() * 4 + serialize(&txin.witness).len();
                        WeightedUtxo {
+                            satisfaction_weight,
                            utxo: Utxo::Foreign {
                                outpoint: txin.previous_output,
-                                sequence: Some(txin.sequence),
                                psbt_input: Box::new(psbt::Input {
                                    witness_utxo: Some(txout.clone()),
-                                    non_witness_utxo: Some(prev_tx.as_ref().clone()),
+                                    non_witness_utxo: Some(prev_tx.clone()),
                                    ..Default::default()
                                }),
                            },
-                            satisfaction_weight,
                        }
                    }
                };
@@ -1741,7 +1670,7 @@ impl<D> Wallet<D> {
            for (index, txout) in tx.output.iter().enumerate() {
                let change_type = self.map_keychain(KeychainKind::Internal);
                match txout_index.index_of_spk(&txout.script_pubkey) {
-                    Some((keychain, _)) if keychain == change_type => change_index = Some(index),
+                    Some(&(keychain, _)) if keychain == change_type => change_index = Some(index),
                    _ => {}
                }
            }
@@ -1753,16 +1682,16 @@ impl<D> Wallet<D> {

        let params = TxParams {
            // TODO: figure out what rbf option should be?
-            version: Some(tx_builder::Version(tx.version.0)),
+            version: Some(tx_builder::Version(tx.version)),
            recipients: tx
                .output
                .into_iter()
-                .map(|txout| (txout.script_pubkey, txout.value.to_sat()))
+                .map(|txout| (txout.script_pubkey, txout.value))
                .collect(),
            utxos: original_utxos,
            bumping_fee: Some(tx_builder::PreviousFee {
                absolute: fee,
-                rate: fee_rate,
+                rate: fee_rate.as_sat_per_vb(),
            }),
            ..Default::default()
        };
@@ -1803,7 +1732,11 @@ impl<D> Wallet<D> {
    /// let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    /// assert!(finalized, "we should have signed all the inputs");
    /// # Ok::<(),anyhow::Error>(())
-    pub fn sign(&self, psbt: &mut Psbt, sign_options: SignOptions) -> Result<bool, SignerError> {
+    pub fn sign(
+        &self,
+        psbt: &mut psbt::PartiallySignedTransaction,
+        sign_options: SignOptions,
+    ) -> Result<bool, SignerError> {
        // This adds all the PSBT metadata for the inputs, which will help us later figure out how
        // to derive our keys
        self.update_psbt_with_descriptor(psbt)
@@ -1883,7 +1816,7 @@ impl<D> Wallet<D> {
    /// The [`SignOptions`] can be used to tweak the behavior of the finalizer.
    pub fn finalize_psbt(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        sign_options: SignOptions,
    ) -> Result<bool, SignerError> {
        let chain_tip = self.chain.tip().block_id();
@@ -1952,15 +1885,6 @@ impl<D> Wallet<D> {
                            if sign_options.remove_partial_sigs {
                                psbt_input.partial_sigs.clear();
                            }
-                            if sign_options.remove_taproot_extras {
-                                // We just constructed the final witness, clear these fields.
-                                psbt_input.tap_key_sig = None;
-                                psbt_input.tap_script_sigs.clear();
-                                psbt_input.tap_scripts.clear();
-                                psbt_input.tap_key_origins.clear();
-                                psbt_input.tap_internal_key = None;
-                                psbt_input.tap_merkle_root = None;
-                            }
                        }
                        Err(_) => finished = false,
                    }
@@ -1969,12 +1893,6 @@ impl<D> Wallet<D> {
            }
        }

-        if finished && sign_options.remove_taproot_extras {
-            for output in &mut psbt.outputs {
-                output.tap_key_origins.clear();
-            }
-        }
-
        Ok(finished)
    }

@@ -2007,10 +1925,10 @@ impl<D> Wallet<D> {
    pub fn cancel_tx(&mut self, tx: &Transaction) {
        let txout_index = &mut self.indexed_graph.index;
        for txout in &tx.output {
-            if let Some((keychain, index)) = txout_index.index_of_spk(&txout.script_pubkey) {
+            if let Some(&(keychain, index)) = txout_index.index_of_spk(&txout.script_pubkey) {
                // NOTE: unmark_used will **not** make something unused if it has actually been used
                // by a tx in the tracker. It only removes the superficial marking.
-                txout_index.unmark_used(keychain, index);
+                txout_index.unmark_used(&keychain, index);
            }
        }
    }
@@ -2026,7 +1944,7 @@ impl<D> Wallet<D> {
    }

    fn get_descriptor_for_txout(&self, txout: &TxOut) -> Option<DerivedDescriptor> {
-        let (keychain, child) = self
+        let &(keychain, child) = self
            .indexed_graph
            .index
            .index_of_spk(&txout.script_pubkey)?;
@@ -2038,37 +1956,30 @@ impl<D> Wallet<D> {
        self.list_unspent()
            .map(|utxo| {
                let keychain = utxo.keychain;
-                (utxo, {
+                #[allow(deprecated)]
+                (
+                    utxo,
                    self.get_descriptor_for_keychain(keychain)
-                        .max_weight_to_satisfy()
-                        .unwrap()
-                })
+                        .max_satisfaction_weight()
+                        .unwrap(),
+                )
            })
            .collect()
    }

    /// Given the options returns the list of utxos that must be used to form the
    /// transaction and any further that may be used if needed.
+    #[allow(clippy::too_many_arguments)]
    fn preselect_utxos(
        &self,
-        params: &TxParams,
+        change_policy: tx_builder::ChangeSpendPolicy,
+        unspendable: &HashSet<OutPoint>,
+        manually_selected: Vec<WeightedUtxo>,
+        must_use_all_available: bool,
+        manual_only: bool,
+        must_only_use_confirmed_tx: bool,
        current_height: Option<u32>,
    ) -> (Vec<WeightedUtxo>, Vec<WeightedUtxo>) {
-        let TxParams {
-            change_policy,
-            unspendable,
-            utxos,
-            drain_wallet,
-            manually_selected_only,
-            bumping_fee,
-            ..
-        } = params;
-
-        let manually_selected = utxos.clone();
-        // we mandate confirmed transactions if we're bumping the fee
-        let must_only_use_confirmed_tx = bumping_fee.is_some();
-        let must_use_all_available = *drain_wallet;
-
        let chain_tip = self.chain.tip().block_id();
        //    must_spend <- manually selected utxos
        //    may_spend  <- all other available utxos
@@ -2083,7 +1994,7 @@ impl<D> Wallet<D> {

        // NOTE: we are intentionally ignoring `unspendable` here. i.e manual
        // selection overrides unspendable.
-        if *manually_selected_only {
+        if manual_only {
            return (must_spend, vec![]);
        }

@@ -2109,7 +2020,7 @@ impl<D> Wallet<D> {
                if must_only_use_confirmed_tx && !confirmation_time.is_confirmed() {
                    return false;
                }
-                if tx.is_coinbase() {
+                if tx.is_coin_base() {
                    debug_assert!(
                        confirmation_time.is_confirmed(),
                        "coinbase must always be confirmed"
@@ -2158,11 +2069,11 @@ impl<D> Wallet<D> {
        tx: Transaction,
        selected: Vec<Utxo>,
        params: TxParams,
-    ) -> Result<Psbt, CreateTxError<D::WriteError>>
+    ) -> Result<psbt::PartiallySignedTransaction, CreateTxError<D::WriteError>>
    where
        D: PersistBackend<ChangeSet>,
    {
-        let mut psbt = Psbt::from_unsigned_tx(tx)?;
+        let mut psbt = psbt::PartiallySignedTransaction::from_unsigned_tx(tx)?;

        if params.add_global_xpubs {
            let all_xpubs = self
@@ -2211,14 +2122,13 @@ impl<D> Wallet<D> {
                        }
                }
                Utxo::Foreign {
-                    outpoint,
                    psbt_input: foreign_psbt_input,
-                    ..
+                    outpoint,
                } => {
                    let is_taproot = foreign_psbt_input
                        .witness_utxo
                        .as_ref()
-                        .map(|txout| txout.script_pubkey.is_p2tr())
+                        .map(|txout| txout.script_pubkey.is_v1_p2tr())
                        .unwrap_or(false);
                    if !is_taproot
                        && !params.only_witness_utxo
@@ -2248,7 +2158,7 @@ impl<D> Wallet<D> {
    {
        // Try to find the prev_script in our db to figure out if this is internal or external,
        // and the derivation index
-        let (keychain, child) = self
+        let &(keychain, child) = self
            .indexed_graph
            .index
            .index_of_spk(&utxo.txout.script_pubkey)
@@ -2274,15 +2184,21 @@ impl<D> Wallet<D> {
                psbt_input.witness_utxo = Some(prev_tx.output[prev_output.vout as usize].clone());
            }
            if !desc.is_taproot() && (!desc.is_witness() || !only_witness_utxo) {
-                psbt_input.non_witness_utxo = Some(prev_tx.as_ref().clone());
+                psbt_input.non_witness_utxo = Some(prev_tx.clone());
            }
        }
        Ok(psbt_input)
    }

-    fn update_psbt_with_descriptor(&self, psbt: &mut Psbt) -> Result<(), MiniscriptPsbtError> {
+    fn update_psbt_with_descriptor(
+        &self,
+        psbt: &mut psbt::PartiallySignedTransaction,
+    ) -> Result<(), MiniscriptPsbtError> {
        // We need to borrow `psbt` mutably within the loops, so we have to allocate a vec for all
        // the input utxos and outputs
+        //
+        // Clippy complains that the collect is not required, but that's wrong
+        #[allow(clippy::needless_collect)]
        let utxos = (0..psbt.inputs.len())
            .filter_map(|i| psbt.get_utxo_for(i).map(|utxo| (true, i, utxo)))
            .chain(
@@ -2296,7 +2212,7 @@ impl<D> Wallet<D> {

        // Try to figure out the keychain and derivation for every input and output
        for (is_input, index, out) in utxos.into_iter() {
-            if let Some((keychain, child)) =
+            if let Some(&(keychain, child)) =
                self.indexed_graph.index.index_of_spk(&out.script_pubkey)
            {
                let desc = self.get_descriptor_for_keychain(keychain);
@@ -2372,7 +2288,7 @@ impl<D> Wallet<D> {
        self.persist.commit().map(|c| c.is_some())
    }

-    /// Returns the changes that will be committed with the next call to [`commit`].
+    /// Returns the changes that will be staged with the next call to [`commit`].
    ///
    /// [`commit`]: Self::commit
    pub fn staged(&self) -> &ChangeSet
@@ -2396,86 +2312,6 @@ impl<D> Wallet<D> {
    pub fn local_chain(&self) -> &LocalChain {
        &self.chain
    }
-
-    /// Introduces a `block` of `height` to the wallet, and tries to connect it to the
-    /// `prev_blockhash` of the block's header.
-    ///
-    /// This is a convenience method that is equivalent to calling [`apply_block_connected_to`]
-    /// with `prev_blockhash` and `height-1` as the `connected_to` parameter.
-    ///
-    /// [`apply_block_connected_to`]: Self::apply_block_connected_to
-    pub fn apply_block(&mut self, block: &Block, height: u32) -> Result<(), CannotConnectError>
-    where
-        D: PersistBackend<ChangeSet>,
-    {
-        let connected_to = match height.checked_sub(1) {
-            Some(prev_height) => BlockId {
-                height: prev_height,
-                hash: block.header.prev_blockhash,
-            },
-            None => BlockId {
-                height,
-                hash: block.block_hash(),
-            },
-        };
-        self.apply_block_connected_to(block, height, connected_to)
-            .map_err(|err| match err {
-                ApplyHeaderError::InconsistentBlocks => {
-                    unreachable!("connected_to is derived from the block so must be consistent")
-                }
-                ApplyHeaderError::CannotConnect(err) => err,
-            })
-    }
-
-    /// Applies relevant transactions from `block` of `height` to the wallet, and connects the
-    /// block to the internal chain.
-    ///
-    /// The `connected_to` parameter informs the wallet how this block connects to the internal
-    /// [`LocalChain`]. Relevant transactions are filtered from the `block` and inserted into the
-    /// internal [`TxGraph`].
-    pub fn apply_block_connected_to(
-        &mut self,
-        block: &Block,
-        height: u32,
-        connected_to: BlockId,
-    ) -> Result<(), ApplyHeaderError>
-    where
-        D: PersistBackend<ChangeSet>,
-    {
-        let mut changeset = ChangeSet::default();
-        changeset.append(
-            self.chain
-                .apply_header_connected_to(&block.header, height, connected_to)?
-                .into(),
-        );
-        changeset.append(
-            self.indexed_graph
-                .apply_block_relevant(block, height)
-                .into(),
-        );
-        self.persist.stage(changeset);
-        Ok(())
-    }
-
-    /// Apply relevant unconfirmed transactions to the wallet.
-    ///
-    /// Transactions that are not relevant are filtered out.
-    ///
-    /// This method takes in an iterator of `(tx, last_seen)` where `last_seen` is the timestamp of
-    /// when the transaction was last seen in the mempool. This is used for conflict resolution
-    /// when there is conflicting unconfirmed transactions. The transaction with the later
-    /// `last_seen` is prioritized.
-    pub fn apply_unconfirmed_txs<'t>(
-        &mut self,
-        unconfirmed_txs: impl IntoIterator<Item = (&'t Transaction, u64)>,
-    ) where
-        D: PersistBackend<ChangeSet>,
-    {
-        let indexed_graph_changeset = self
-            .indexed_graph
-            .batch_insert_relevant_unconfirmed(unconfirmed_txs);
-        self.persist.stage(ChangeSet::from(indexed_graph_changeset));
-    }
 }

 impl<D> AsRef<bdk_chain::tx_graph::TxGraph<ConfirmationTimeHeightAnchor>> for Wallet<D> {
@@ -2554,17 +2390,6 @@ fn create_signers<E: IntoWalletDescriptor>(
    Ok((signers, change_signers))
 }

-/// Transforms a [`FeeRate`] to `f64` with unit as sat/vb.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! floating_rate {
-    ($rate:expr) => {{
-        use $crate::bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
-        // sat_kwu / 250.0 -> sat_vb
-        $rate.to_sat_per_kwu() as f64 / ((1000 / WITNESS_SCALE_FACTOR) as f64)
-    }};
-}
-
 #[macro_export]
 #[doc(hidden)]
 /// Macro for getting a wallet for use in a doctest
@@ -2584,11 +2409,11 @@ macro_rules! doctest_wallet {
        .unwrap();
        let address = wallet.get_address(AddressIndex::New).address;
        let tx = Transaction {
-            version: transaction::Version::ONE,
+            version: 1,
            lock_time: absolute::LockTime::ZERO,
            input: vec![],
            output: vec![TxOut {
-                value: Amount::from_sat(500_000),
+                value: 500_000,
                script_pubkey: address.script_pubkey(),
            }],
        };
--- a/crates/bdk/src/wallet/signer.rs
+++ b/crates/bdk/src/wallet/signer.rs
@@ -19,12 +19,13 @@
 //! # use core::str::FromStr;
 //! # use bitcoin::secp256k1::{Secp256k1, All};
 //! # use bitcoin::*;
+//! # use bitcoin::psbt;
 //! # use bdk::signer::*;
 //! # use bdk::*;
 //! # #[derive(Debug)]
 //! # struct CustomHSM;
 //! # impl CustomHSM {
-//! #     fn hsm_sign_input(&self, _psbt: &mut Psbt, _input: usize) -> Result<(), SignerError> {
+//! #     fn hsm_sign_input(&self, _psbt: &mut psbt::PartiallySignedTransaction, _input: usize) -> Result<(), SignerError> {
 //! #         Ok(())
 //! #     }
 //! #     fn connect() -> Self {
@@ -54,7 +55,7 @@
 //! impl InputSigner for CustomSigner {
 //!     fn sign_input(
 //!         &self,
-//!         psbt: &mut Psbt,
+//!         psbt: &mut psbt::PartiallySignedTransaction,
 //!         input_index: usize,
 //!         _sign_options: &SignOptions,
 //!         _secp: &Secp256k1<All>,
@@ -79,20 +80,19 @@
 //! ```

 use crate::collections::BTreeMap;
-use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::cmp::Ordering;
 use core::fmt;
 use core::ops::{Bound::Included, Deref};

-use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpriv};
+use bitcoin::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, Fingerprint};
 use bitcoin::hashes::hash160;
 use bitcoin::secp256k1::Message;
 use bitcoin::sighash::{EcdsaSighashType, TapSighash, TapSighashType};
 use bitcoin::{ecdsa, psbt, sighash, taproot};
 use bitcoin::{key::TapTweak, key::XOnlyPublicKey, secp256k1};
-use bitcoin::{PrivateKey, Psbt, PublicKey};
+use bitcoin::{PrivateKey, PublicKey};

 use miniscript::descriptor::{
    Descriptor, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey,
@@ -162,10 +162,16 @@ pub enum SignerError {
    SighashError(sighash::Error),
    /// Miniscript PSBT error
    MiniscriptPsbt(MiniscriptPsbtError),
-    /// To be used only by external libraries implementing [`InputSigner`] or
-    /// [`TransactionSigner`], so that they can return their own custom errors, without having to
-    /// modify [`SignerError`] in BDK.
-    External(String),
+    /// Error while signing using hardware wallets
+    #[cfg(feature = "hardware-signer")]
+    HWIError(hwi::error::Error),
+}
+
+#[cfg(feature = "hardware-signer")]
+impl From<hwi::error::Error> for SignerError {
+    fn from(e: hwi::error::Error) -> Self {
+        SignerError::HWIError(e)
+    }
 }

 impl From<sighash::Error> for SignerError {
@@ -190,7 +196,8 @@ impl fmt::Display for SignerError {
            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),
            Self::MiniscriptPsbt(err) => write!(f, "Miniscript PSBT error: {}", err),
-            Self::External(err) => write!(f, "{}", err),
+            #[cfg(feature = "hardware-signer")]
+            Self::HWIError(err) => write!(f, "Error while signing using hardware wallets: {}", err),
        }
    }
 }
@@ -214,7 +221,7 @@ pub enum SignerContext {
    },
 }

-/// Wrapper to pair a signer with its context
+/// Wrapper structure to pair a signer with its context
 #[derive(Debug, Clone)]
 pub struct SignerWrapper<S: Sized + fmt::Debug + Clone> {
    signer: S,
@@ -263,7 +270,7 @@ pub trait InputSigner: SignerCommon {
    /// Sign a single psbt input
    fn sign_input(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        input_index: usize,
        sign_options: &SignOptions,
        secp: &SecpCtx,
@@ -278,7 +285,7 @@ pub trait TransactionSigner: SignerCommon {
    /// Sign all the inputs of the psbt
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        sign_options: &SignOptions,
        secp: &SecpCtx,
    ) -> Result<(), SignerError>;
@@ -287,7 +294,7 @@ pub trait TransactionSigner: SignerCommon {
 impl<T: InputSigner> TransactionSigner for T {
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        sign_options: &SignOptions,
        secp: &SecpCtx,
    ) -> Result<(), SignerError> {
@@ -299,7 +306,7 @@ impl<T: InputSigner> TransactionSigner for T {
    }
 }

-impl SignerCommon for SignerWrapper<DescriptorXKey<Xpriv>> {
+impl SignerCommon for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
    fn id(&self, secp: &SecpCtx) -> SignerId {
        SignerId::from(self.root_fingerprint(secp))
    }
@@ -309,10 +316,10 @@ impl SignerCommon for SignerWrapper<DescriptorXKey<Xpriv>> {
    }
 }

-impl InputSigner for SignerWrapper<DescriptorXKey<Xpriv>> {
+impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
    fn sign_input(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        input_index: usize,
        sign_options: &SignOptions,
        secp: &SecpCtx,
@@ -395,7 +402,7 @@ fn multikey_to_xkeys<K: InnerXKey + Clone>(
        .collect()
 }

-impl SignerCommon for SignerWrapper<DescriptorMultiXKey<Xpriv>> {
+impl SignerCommon for SignerWrapper<DescriptorMultiXKey<ExtendedPrivKey>> {
    fn id(&self, secp: &SecpCtx) -> SignerId {
        SignerId::from(self.root_fingerprint(secp))
    }
@@ -405,10 +412,10 @@ impl SignerCommon for SignerWrapper<DescriptorMultiXKey<Xpriv>> {
    }
 }

-impl InputSigner for SignerWrapper<DescriptorMultiXKey<Xpriv>> {
+impl InputSigner for SignerWrapper<DescriptorMultiXKey<ExtendedPrivKey>> {
    fn sign_input(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        input_index: usize,
        sign_options: &SignOptions,
        secp: &SecpCtx,
@@ -437,7 +444,7 @@ impl SignerCommon for SignerWrapper<PrivateKey> {
 impl InputSigner for SignerWrapper<PrivateKey> {
    fn sign_input(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        input_index: usize,
        sign_options: &SignOptions,
        secp: &SecpCtx,
@@ -576,7 +583,7 @@ fn sign_psbt_schnorr(
    hash_ty: TapSighashType,
    secp: &SecpCtx,
 ) {
-    let keypair = secp256k1::Keypair::from_seckey_slice(secp, secret_key.as_ref()).unwrap();
+    let keypair = secp256k1::KeyPair::from_seckey_slice(secp, secret_key.as_ref()).unwrap();
    let keypair = match leaf_hash {
        None => keypair
            .tap_tweak(secp, psbt_input.tap_merkle_root)
@@ -781,16 +788,6 @@ pub struct SignOptions {
    /// Defaults to `true` which will remove partial signatures during finalization.
    pub remove_partial_sigs: bool,

-    /// Whether to remove taproot specific fields from the PSBT on finalization.
-    ///
-    /// For inputs this includes the taproot internal key, merkle root, and individual
-    /// scripts and signatures. For both inputs and outputs it includes key origin info.
-    ///
-    /// Defaults to `true` which will remove all of the above mentioned fields when finalizing.
-    ///
-    /// See [`BIP371`](https://github.com/bitcoin/bips/blob/master/bip-0371.mediawiki) for details.
-    pub remove_taproot_extras: bool,
-
    /// Whether to try finalizing the PSBT after the inputs are signed.
    ///
    /// Defaults to `true` which will try finalizing PSBT after inputs are signed.
@@ -815,10 +812,9 @@ pub struct SignOptions {
 }

 /// Customize which taproot script-path leaves the signer should sign.
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TapLeavesOptions {
    /// The signer will sign all the leaves it has a key for.
-    #[default]
    All,
    /// The signer won't sign leaves other than the ones specified. Note that it could still ignore
    /// some of the specified leaves, if it doesn't have the right key to sign them.
@@ -829,6 +825,13 @@ pub enum TapLeavesOptions {
    None,
 }

+impl Default for TapLeavesOptions {
+    fn default() -> Self {
+        TapLeavesOptions::All
+    }
+}
+
+#[allow(clippy::derivable_impls)]
 impl Default for SignOptions {
    fn default() -> Self {
        SignOptions {
@@ -836,7 +839,6 @@ impl Default for SignOptions {
            assume_height: None,
            allow_all_sighashes: false,
            remove_partial_sigs: true,
-            remove_taproot_extras: true,
            try_finalize: true,
            tap_leaves_options: TapLeavesOptions::default(),
            sign_with_tap_internal_key: true,
@@ -851,7 +853,7 @@ pub(crate) trait ComputeSighash {
    type SighashType;

    fn sighash(
-        psbt: &Psbt,
+        psbt: &psbt::PartiallySignedTransaction,
        input_index: usize,
        extra: Self::Extra,
    ) -> Result<(Self::Sighash, Self::SighashType), SignerError>;
@@ -863,7 +865,7 @@ impl ComputeSighash for Legacy {
    type SighashType = EcdsaSighashType;

    fn sighash(
-        psbt: &Psbt,
+        psbt: &psbt::PartiallySignedTransaction,
        input_index: usize,
        _extra: (),
    ) -> Result<(Self::Sighash, Self::SighashType), SignerError> {
@@ -912,7 +914,7 @@ impl ComputeSighash for Segwitv0 {
    type SighashType = EcdsaSighashType;

    fn sighash(
-        psbt: &Psbt,
+        psbt: &psbt::PartiallySignedTransaction,
        input_index: usize,
        _extra: (),
    ) -> Result<(Self::Sighash, Self::SighashType), SignerError> {
@@ -923,7 +925,7 @@ impl ComputeSighash for Segwitv0 {
        let psbt_input = &psbt.inputs[input_index];
        let tx_input = &psbt.unsigned_tx.input[input_index];

-        let sighash_type = psbt_input
+        let sighash = psbt_input
            .sighash_type
            .unwrap_or_else(|| EcdsaSighashType::All.into())
            .ecdsa_hash_ty()
@@ -951,39 +953,40 @@ impl ComputeSighash for Segwitv0 {
        };
        let value = utxo.value;

-        let mut sighasher = sighash::SighashCache::new(&psbt.unsigned_tx);
-
-        let sighash = match psbt_input.witness_script {
-            Some(ref witness_script) => {
-                sighasher.p2wsh_signature_hash(input_index, witness_script, value, sighash_type)?
-            }
+        let script = match psbt_input.witness_script {
+            Some(ref witness_script) => witness_script.clone(),
            None => {
-                if utxo.script_pubkey.is_p2wpkh() {
-                    sighasher.p2wpkh_signature_hash(
-                        input_index,
-                        &utxo.script_pubkey,
-                        value,
-                        sighash_type,
-                    )?
+                if utxo.script_pubkey.is_v0_p2wpkh() {
+                    utxo.script_pubkey
+                        .p2wpkh_script_code()
+                        .expect("We check above that the spk is a p2wpkh")
                } else if psbt_input
                    .redeem_script
                    .as_ref()
-                    .map(|s| s.is_p2wpkh())
+                    .map(|s| s.is_v0_p2wpkh())
                    .unwrap_or(false)
                {
-                    let script_pubkey = psbt_input.redeem_script.as_ref().unwrap();
-                    sighasher.p2wpkh_signature_hash(
-                        input_index,
-                        script_pubkey,
-                        value,
-                        sighash_type,
-                    )?
+                    psbt_input
+                        .redeem_script
+                        .as_ref()
+                        .unwrap()
+                        .p2wpkh_script_code()
+                        .expect("We check above that the spk is a p2wpkh")
                } else {
                    return Err(SignerError::MissingWitnessScript);
                }
            }
        };
-        Ok((sighash, sighash_type))
+
+        Ok((
+            sighash::SighashCache::new(&psbt.unsigned_tx).segwit_signature_hash(
+                input_index,
+                &script,
+                value,
+                sighash,
+            )?,
+            sighash,
+        ))
    }
 }

@@ -993,7 +996,7 @@ impl ComputeSighash for Tap {
    type SighashType = TapSighashType;

    fn sighash(
-        psbt: &Psbt,
+        psbt: &psbt::PartiallySignedTransaction,
        input_index: usize,
        extra: Self::Extra,
    ) -> Result<(Self::Sighash, TapSighashType), SignerError> {
@@ -1164,7 +1167,7 @@ mod signers_container_tests {
    impl TransactionSigner for DummySigner {
        fn sign_transaction(
            &self,
-            _psbt: &mut Psbt,
+            _psbt: &mut psbt::PartiallySignedTransaction,
            _sign_options: &SignOptions,
            _secp: &SecpCtx,
        ) -> Result<(), SignerError> {
@@ -1182,8 +1185,8 @@ mod signers_container_tests {
    ) -> (DescriptorKey<Ctx>, DescriptorKey<Ctx>, Fingerprint) {
        let secp: Secp256k1<All> = Secp256k1::new();
        let path = bip32::DerivationPath::from_str(PATH).unwrap();
-        let tprv = bip32::Xpriv::from_str(tprv).unwrap();
-        let tpub = bip32::Xpub::from_priv(&secp, &tprv);
+        let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
+        let tpub = bip32::ExtendedPubKey::from_priv(&secp, &tprv);
        let fingerprint = tprv.fingerprint(&secp);
        let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
        let pubkey = (tpub, path).into_descriptor_key().unwrap();
--- a/crates/bdk/src/wallet/tx_builder.rs
+++ b/crates/bdk/src/wallet/tx_builder.rs
@@ -31,7 +31,7 @@
 //!     // Create a transaction with one output to `to_address` of 50_000 satoshi
 //!     .add_recipient(to_address.script_pubkey(), 50_000)
 //!     // With a custom fee rate of 5.0 satoshi/vbyte
-//!     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"))
+//!     .fee_rate(bdk::FeeRate::from_sat_per_vb(5.0))
 //!     // Only spend non-change outputs
 //!     .do_not_spend_change()
 //!     // Turn on RBF signaling
@@ -40,20 +40,22 @@
 //! # Ok::<(), anyhow::Error>(())
 //! ```

+use crate::collections::BTreeMap;
+use crate::collections::HashSet;
 use alloc::{boxed::Box, rc::Rc, string::String, vec::Vec};
+use bdk_chain::PersistBackend;
 use core::cell::RefCell;
 use core::fmt;
 use core::marker::PhantomData;

-use bdk_chain::PersistBackend;
-use bitcoin::psbt::{self, Psbt};
-use bitcoin::script::PushBytes;
-use bitcoin::{absolute, FeeRate, OutPoint, ScriptBuf, Sequence, Transaction, Txid};
+use bitcoin::psbt::{self, PartiallySignedTransaction as Psbt};
+use bitcoin::{absolute, script::PushBytes, OutPoint, ScriptBuf, Sequence, Transaction, Txid};

 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
-use super::{ChangeSet, CreateTxError, Wallet};
-use crate::collections::{BTreeMap, HashSet};
-use crate::{KeychainKind, LocalOutput, Utxo, WeightedUtxo};
+use super::ChangeSet;
+use crate::types::{FeeRate, KeychainKind, LocalOutput, WeightedUtxo};
+use crate::wallet::CreateTxError;
+use crate::{Utxo, Wallet};

 /// Context in which the [`TxBuilder`] is valid
 pub trait TxBuilderContext: core::fmt::Debug + Default + Clone {}
@@ -161,7 +163,7 @@ pub(crate) struct TxParams {
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct PreviousFee {
    pub absolute: u64,
-    pub rate: FeeRate,
+    pub rate: f32,
 }

 #[derive(Debug, Clone, Copy)]
@@ -172,7 +174,7 @@ pub(crate) enum FeePolicy {

 impl Default for FeePolicy {
    fn default() -> Self {
-        FeePolicy::FeeRate(FeeRate::BROADCAST_MIN)
+        FeePolicy::FeeRate(FeeRate::default_min_relay_fee())
    }
 }

@@ -188,13 +190,15 @@ impl<'a, D, Cs: Clone, Ctx> Clone for TxBuilder<'a, D, Cs, Ctx> {
 }

 // methods supported by both contexts, for any CoinSelectionAlgorithm
-impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
-    /// Set a custom fee rate.
-    ///
-    /// This method sets the mining fee paid by the transaction as a rate on its size.
-    /// This means that the total fee paid is equal to `fee_rate` times the size
-    /// of the transaction. Default is 1 sat/vB in accordance with Bitcoin Core's default
-    /// relay policy.
+impl<'a, D, Cs: CoinSelectionAlgorithm, Ctx: TxBuilderContext> TxBuilder<'a, D, Cs, Ctx> {
+    /// Set a custom fee rate
+    /// The fee_rate method sets the mining fee paid by the transaction as a rate on its size.
+    /// This means that the total fee paid is equal to this rate * size of the transaction in virtual Bytes (vB) or Weight Unit (wu).
+    /// This rate is internally expressed in satoshis-per-virtual-bytes (sats/vB) using FeeRate::from_sat_per_vb, but can also be set by:
+    /// * sats/kvB (1000 sats/kvB == 1 sats/vB) using FeeRate::from_sat_per_kvb
+    /// * btc/kvB (0.00001000 btc/kvB == 1 sats/vB) using FeeRate::from_btc_per_kvb
+    /// * sats/kwu (250 sats/kwu == 1 sats/vB) using FeeRate::from_sat_per_kwu
+    /// Default is 1 sat/vB (see min_relay_fee)
    ///
    /// Note that this is really a minimum feerate -- it's possible to
    /// overshoot it slightly since adding a change output to drain the remaining
@@ -314,7 +318,8 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {

            for utxo in utxos {
                let descriptor = wallet.get_descriptor_for_keychain(utxo.keychain);
-                let satisfaction_weight = descriptor.max_weight_to_satisfy().unwrap();
+                #[allow(deprecated)]
+                let satisfaction_weight = descriptor.max_satisfaction_weight().unwrap();
                self.params.utxos.push(WeightedUtxo {
                    satisfaction_weight,
                    utxo: Utxo::Local(utxo),
@@ -355,9 +360,9 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
    /// causing you to pay a fee that is too high. The party who is broadcasting the transaction can
    /// of course check the real input weight matches the expected weight prior to broadcasting.
    ///
-    /// To guarantee the `max_weight_to_satisfy` is correct, you can require the party providing the
+    /// To guarantee the `satisfaction_weight` is correct, you can require the party providing the
    /// `psbt_input` provide a miniscript descriptor for the input so you can check it against the
-    /// `script_pubkey` and then ask it for the [`max_weight_to_satisfy`].
+    /// `script_pubkey` and then ask it for the [`max_satisfaction_weight`].
    ///
    /// This is an **EXPERIMENTAL** feature, API and other major changes are expected.
    ///
@@ -378,28 +383,12 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
    ///
    /// [`only_witness_utxo`]: Self::only_witness_utxo
    /// [`finish`]: Self::finish
-    /// [`max_weight_to_satisfy`]: miniscript::Descriptor::max_weight_to_satisfy
+    /// [`max_satisfaction_weight`]: miniscript::Descriptor::max_satisfaction_weight
    pub fn add_foreign_utxo(
        &mut self,
        outpoint: OutPoint,
        psbt_input: psbt::Input,
        satisfaction_weight: usize,
-    ) -> Result<&mut Self, AddForeignUtxoError> {
-        self.add_foreign_utxo_with_sequence(
-            outpoint,
-            psbt_input,
-            satisfaction_weight,
-            Sequence::MAX,
-        )
-    }
-
-    /// Same as [add_foreign_utxo](TxBuilder::add_foreign_utxo) but allows to set the nSequence value.
-    pub fn add_foreign_utxo_with_sequence(
-        &mut self,
-        outpoint: OutPoint,
-        psbt_input: psbt::Input,
-        satisfaction_weight: usize,
-        sequence: Sequence,
    ) -> Result<&mut Self, AddForeignUtxoError> {
        if psbt_input.witness_utxo.is_none() {
            match psbt_input.non_witness_utxo.as_ref() {
@@ -424,7 +413,6 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
            satisfaction_weight,
            utxo: Utxo::Foreign {
                outpoint,
-                sequence: Some(sequence),
                psbt_input: Box::new(psbt_input),
            },
        });
@@ -569,6 +557,20 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
        }
    }

+    /// Finish building the transaction.
+    ///
+    /// Returns a new [`Psbt`] per [`BIP174`].
+    ///
+    /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
+    pub fn finish(self) -> Result<Psbt, CreateTxError<D::WriteError>>
+    where
+        D: PersistBackend<ChangeSet>,
+    {
+        self.wallet
+            .borrow_mut()
+            .create_tx(self.coin_selection, self.params)
+    }
+
    /// Enable signaling RBF
    ///
    /// This will use the default nSequence value of `0xFFFFFFFD`.
@@ -615,22 +617,6 @@ impl<'a, D, Cs, Ctx> TxBuilder<'a, D, Cs, Ctx> {
    }
 }

-impl<'a, D, Cs: CoinSelectionAlgorithm, Ctx> TxBuilder<'a, D, Cs, Ctx> {
-    /// Finish building the transaction.
-    ///
-    /// Returns a new [`Psbt`] per [`BIP174`].
-    ///
-    /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
-    pub fn finish(self) -> Result<Psbt, CreateTxError<D::WriteError>>
-    where
-        D: PersistBackend<ChangeSet>,
-    {
-        self.wallet
-            .borrow_mut()
-            .create_tx(self.coin_selection, self.params)
-    }
-}
-
 #[derive(Debug)]
 /// Error returned from [`TxBuilder::add_utxo`] and [`TxBuilder::add_utxos`]
 pub enum AddUtxoError {
@@ -776,7 +762,7 @@ impl<'a, D, Cs: CoinSelectionAlgorithm> TxBuilder<'a, D, Cs, CreateTx> {
    ///     .drain_wallet()
    ///     // Send the excess (which is all the coins minus the fee) to this address.
    ///     .drain_to(to_address.script_pubkey())
-    ///     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"))
+    ///     .fee_rate(bdk::FeeRate::from_sat_per_vb(5.0))
    ///     .enable_rbf();
    /// let psbt = tx_builder.finish()?;
    /// # Ok::<(), anyhow::Error>(())
@@ -825,10 +811,9 @@ impl<'a, D> TxBuilder<'a, D, DefaultCoinSelectionAlgorithm, BumpFee> {
 }

 /// Ordering of the transaction's inputs and outputs
-#[derive(Default, Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum TxOrdering {
    /// Randomized (default)
-    #[default]
    Shuffle,
    /// Unchanged
    Untouched,
@@ -836,6 +821,12 @@ pub enum TxOrdering {
    Bip69Lexicographic,
 }

+impl Default for TxOrdering {
+    fn default() -> Self {
+        TxOrdering::Shuffle
+    }
+}
+
 impl TxOrdering {
    /// Sort transaction inputs and outputs by [`TxOrdering`] variant
    pub fn sort_tx(&self, tx: &mut Transaction) {
@@ -889,10 +880,9 @@ impl RbfValue {
 }

 /// Policy regarding the use of change outputs when creating a transaction
-#[derive(Default, Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum ChangeSpendPolicy {
    /// Use both change and non-change outputs (default)
-    #[default]
    ChangeAllowed,
    /// Only use change outputs (see [`TxBuilder::only_spend_change`])
    OnlyChange,
@@ -900,6 +890,12 @@ pub enum ChangeSpendPolicy {
    ChangeForbidden,
 }

+impl Default for ChangeSpendPolicy {
+    fn default() -> Self {
+        ChangeSpendPolicy::ChangeAllowed
+    }
+}
+
 impl ChangeSpendPolicy {
    pub(crate) fn is_satisfied_by(&self, utxo: &LocalOutput) -> bool {
        match self {
@@ -927,8 +923,7 @@ mod test {

    use bdk_chain::ConfirmationTime;
    use bitcoin::consensus::deserialize;
-    use bitcoin::hex::FromHex;
-    use bitcoin::TxOut;
+    use bitcoin::hashes::hex::FromHex;

    use super::*;

@@ -999,7 +994,7 @@ mod test {
            .unwrap()
        );

-        assert_eq!(tx.output[0].value.to_sat(), 800);
+        assert_eq!(tx.output[0].value, 800);
        assert_eq!(tx.output[1].script_pubkey, ScriptBuf::from(vec![0xAA]));
        assert_eq!(
            tx.output[2].script_pubkey,
@@ -1016,7 +1011,7 @@ mod test {
                    txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(),
                    vout: 0,
                },
-                txout: TxOut::NULL,
+                txout: Default::default(),
                keychain: KeychainKind::External,
                is_spent: false,
                confirmation_time: ConfirmationTime::Unconfirmed { last_seen: 0 },
@@ -1027,7 +1022,7 @@ mod test {
                    txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(),
                    vout: 1,
                },
-                txout: TxOut::NULL,
+                txout: Default::default(),
                keychain: KeychainKind::Internal,
                is_spent: false,
                confirmation_time: ConfirmationTime::Confirmed {
--- a/crates/bdk/src/wallet/utils.rs
+++ b/crates/bdk/src/wallet/utils.rs
@@ -138,7 +138,7 @@ mod test {
            .require_network(Network::Bitcoin)
            .unwrap()
            .script_pubkey();
-        assert!(script_p2wpkh.is_p2wpkh());
+        assert!(script_p2wpkh.is_v0_p2wpkh());
        assert!(293.is_dust(&script_p2wpkh));
        assert!(!294.is_dust(&script_p2wpkh));
    }
--- a/crates/bdk/tests/common.rs
+++ b/crates/bdk/tests/common.rs
@@ -4,10 +4,7 @@ use bdk::{wallet::AddressIndex, KeychainKind, LocalOutput, Wallet};
 use bdk_chain::indexed_tx_graph::Indexer;
 use bdk_chain::{BlockId, ConfirmationTime};
 use bitcoin::hashes::Hash;
-use bitcoin::{
-    transaction, Address, Amount, BlockHash, FeeRate, Network, OutPoint, Transaction, TxIn, TxOut,
-    Txid,
-};
+use bitcoin::{Address, BlockHash, Network, OutPoint, Transaction, TxIn, TxOut, Txid};
 use std::str::FromStr;

 // Return a fake wallet that appears to be funded for testing.
@@ -27,7 +24,7 @@ pub fn get_funded_wallet_with_change(
        .unwrap();

    let tx0 = Transaction {
-        version: transaction::Version::ONE,
+        version: 1,
        lock_time: bitcoin::absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint {
@@ -39,13 +36,13 @@ pub fn get_funded_wallet_with_change(
            witness: Default::default(),
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(76_000),
+            value: 76_000,
            script_pubkey: change_address.script_pubkey(),
        }],
    };

    let tx1 = Transaction {
-        version: transaction::Version::ONE,
+        version: 1,
        lock_time: bitcoin::absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint {
@@ -58,11 +55,11 @@ pub fn get_funded_wallet_with_change(
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(50_000),
+                value: 50_000,
                script_pubkey: change_address.script_pubkey(),
            },
            TxOut {
-                value: Amount::from_sat(25_000),
+                value: 25_000,
                script_pubkey: sendto_address.script_pubkey(),
            },
        ],
@@ -157,16 +154,3 @@ pub fn get_test_tr_with_taptree_xprv() -> &'static str {
 pub fn get_test_tr_dup_keys() -> &'static str {
    "tr(cNJmN3fH9DDbDt131fQNkVakkpzawJBSeybCUNmP1BovpmGQ45xG,{pk(8aee2b8120a5f157f1223f72b5e62b825831a27a9fdf427db7cc697494d4a642),pk(8aee2b8120a5f157f1223f72b5e62b825831a27a9fdf427db7cc697494d4a642)})"
 }
-
-/// Construct a new [`FeeRate`] from the given raw `sat_vb` feerate. This is
-/// useful in cases where we want to create a feerate from a `f64`, as the
-/// traditional [`FeeRate::from_sat_per_vb`] method will only accept an integer.
-///
-/// **Note** this 'quick and dirty' conversion should only be used when the input
-/// parameter has units of `satoshis/vbyte` **AND** is not expected to overflow,
-/// or else the resulting value will be inaccurate.
-pub fn feerate_unchecked(sat_vb: f64) -> FeeRate {
-    // 1 sat_vb / 4wu_vb * 1000kwu_wu = 250 sat_kwu
-    let sat_kwu = (sat_vb * 250.0).ceil() as u64;
-    FeeRate::from_sat_per_kwu(sat_kwu)
-}
--- a/crates/bdk/tests/psbt.rs
+++ b/crates/bdk/tests/psbt.rs
@@ -1,7 +1,8 @@
-use bdk::bitcoin::{Amount, FeeRate, Psbt, TxIn};
+use bdk::bitcoin::TxIn;
 use bdk::wallet::AddressIndex;
 use bdk::wallet::AddressIndex::New;
-use bdk::{psbt, SignOptions};
+use bdk::{psbt, FeeRate, SignOptions};
+use bitcoin::psbt::PartiallySignedTransaction as Psbt;
 use core::str::FromStr;
 mod common;
 use common::*;
@@ -81,13 +82,13 @@ fn test_psbt_sign_with_finalized() {
 fn test_psbt_fee_rate_with_witness_utxo() {
    use psbt::PsbtUtils;

-    let expected_fee_rate = FeeRate::from_sat_per_kwu(310);
+    let expected_fee_rate = 1.2345;

    let (mut wallet, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
    let addr = wallet.get_address(New);
    let mut builder = wallet.build_tx();
    builder.drain_to(addr.script_pubkey()).drain_wallet();
-    builder.fee_rate(expected_fee_rate);
+    builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
    let mut psbt = builder.finish().unwrap();
    let fee_amount = psbt.fee_amount();
    assert!(fee_amount.is_some());
@@ -98,21 +99,21 @@ fn test_psbt_fee_rate_with_witness_utxo() {
    assert!(finalized);

    let finalized_fee_rate = psbt.fee_rate().unwrap();
-    assert!(finalized_fee_rate >= expected_fee_rate);
-    assert!(finalized_fee_rate < unfinalized_fee_rate);
+    assert!(finalized_fee_rate.as_sat_per_vb() >= expected_fee_rate);
+    assert!(finalized_fee_rate.as_sat_per_vb() < unfinalized_fee_rate.as_sat_per_vb());
 }

 #[test]
 fn test_psbt_fee_rate_with_nonwitness_utxo() {
    use psbt::PsbtUtils;

-    let expected_fee_rate = FeeRate::from_sat_per_kwu(310);
+    let expected_fee_rate = 1.2345;

    let (mut wallet, _) = get_funded_wallet("pkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
    let addr = wallet.get_address(New);
    let mut builder = wallet.build_tx();
    builder.drain_to(addr.script_pubkey()).drain_wallet();
-    builder.fee_rate(expected_fee_rate);
+    builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
    let mut psbt = builder.finish().unwrap();
    let fee_amount = psbt.fee_amount();
    assert!(fee_amount.is_some());
@@ -122,21 +123,21 @@ fn test_psbt_fee_rate_with_nonwitness_utxo() {
    assert!(finalized);

    let finalized_fee_rate = psbt.fee_rate().unwrap();
-    assert!(finalized_fee_rate >= expected_fee_rate);
-    assert!(finalized_fee_rate < unfinalized_fee_rate);
+    assert!(finalized_fee_rate.as_sat_per_vb() >= expected_fee_rate);
+    assert!(finalized_fee_rate.as_sat_per_vb() < unfinalized_fee_rate.as_sat_per_vb());
 }

 #[test]
 fn test_psbt_fee_rate_with_missing_txout() {
    use psbt::PsbtUtils;

-    let expected_fee_rate = FeeRate::from_sat_per_kwu(310);
+    let expected_fee_rate = 1.2345;

    let (mut wpkh_wallet,  _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
    let addr = wpkh_wallet.get_address(New);
    let mut builder = wpkh_wallet.build_tx();
    builder.drain_to(addr.script_pubkey()).drain_wallet();
-    builder.fee_rate(expected_fee_rate);
+    builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
    let mut wpkh_psbt = builder.finish().unwrap();

    wpkh_psbt.inputs[0].witness_utxo = None;
@@ -148,7 +149,7 @@ fn test_psbt_fee_rate_with_missing_txout() {
    let addr = pkh_wallet.get_address(New);
    let mut builder = pkh_wallet.build_tx();
    builder.drain_to(addr.script_pubkey()).drain_wallet();
-    builder.fee_rate(expected_fee_rate);
+    builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
    let mut pkh_psbt = builder.finish().unwrap();

    pkh_psbt.inputs[0].non_witness_utxo = None;
@@ -160,26 +161,16 @@ fn test_psbt_fee_rate_with_missing_txout() {
 fn test_psbt_multiple_internalkey_signers() {
    use bdk::signer::{SignerContext, SignerOrdering, SignerWrapper};
    use bdk::KeychainKind;
-    use bitcoin::key::TapTweak;
-    use bitcoin::secp256k1::{schnorr, Keypair, Message, Secp256k1, XOnlyPublicKey};
-    use bitcoin::sighash::{Prevouts, SighashCache, TapSighashType};
-    use bitcoin::{PrivateKey, TxOut};
+    use bitcoin::{secp256k1::Secp256k1, PrivateKey};
+    use miniscript::psbt::PsbtExt;
    use std::sync::Arc;

    let secp = Secp256k1::new();
-    let wif = "cNJmN3fH9DDbDt131fQNkVakkpzawJBSeybCUNmP1BovpmGQ45xG";
-    let desc = format!("tr({})", wif);
-    let prv = PrivateKey::from_wif(wif).unwrap();
-    let keypair = Keypair::from_secret_key(&secp, &prv.inner);
-
-    let (mut wallet, _) = get_funded_wallet(&desc);
-    let to_spend = wallet.get_balance().total();
+    let (mut wallet, _) = get_funded_wallet(get_test_tr_single_sig());
    let send_to = wallet.get_address(AddressIndex::New);
    let mut builder = wallet.build_tx();
-    builder.drain_to(send_to.script_pubkey()).drain_wallet();
+    builder.add_recipient(send_to.script_pubkey(), 10_000);
    let mut psbt = builder.finish().unwrap();
-    let unsigned_tx = psbt.unsigned_tx.clone();
-
    // Adds a signer for the wrong internal key, bdk should not use this key to sign
    wallet.add_signer(
        KeychainKind::External,
@@ -192,32 +183,10 @@ fn test_psbt_multiple_internalkey_signers() {
            },
        )),
    );
-    let finalized = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
-    assert!(finalized);
-
-    // To verify, we need the signature, message, and pubkey
-    let witness = psbt.inputs[0].final_script_witness.as_ref().unwrap();
-    assert!(!witness.is_empty());
-    let signature = schnorr::Signature::from_slice(witness.iter().next().unwrap()).unwrap();
-
-    // the prevout we're spending
-    let prevouts = &[TxOut {
-        script_pubkey: send_to.script_pubkey(),
-        value: Amount::from_sat(to_spend),
-    }];
-    let prevouts = Prevouts::All(prevouts);
-    let input_index = 0;
-    let mut sighash_cache = SighashCache::new(unsigned_tx);
-    let sighash = sighash_cache
-        .taproot_key_spend_signature_hash(input_index, &prevouts, TapSighashType::Default)
-        .unwrap();
-    let message = Message::from(sighash);
-
-    // add tweak. this was taken from `signer::sign_psbt_schnorr`
-    let keypair = keypair.tap_tweak(&secp, None).to_inner();
-    let (xonlykey, _parity) = XOnlyPublicKey::from_keypair(&keypair);
-
-    // Must verify if we used the correct key to sign
-    let verify_res = secp.verify_schnorr(&signature, &message, &xonlykey);
-    assert!(verify_res.is_ok(), "The wrong internal key was used");
+    let _ = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
+    // Checks that we signed using the right key
+    assert!(
+        psbt.finalize_mut(&secp).is_ok(),
+        "The wrong internal key was used"
+    );
 }
--- a/crates/bdk/tests/wallet.rs
+++ b/crates/bdk/tests/wallet.rs
--- a/crates/bitcoind_rpc/Cargo.toml
+++ b/crates/bitcoind_rpc/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "bdk_bitcoind_rpc"
-version = "0.8.0"
+version = "0.1.0"
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.57"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
 documentation = "https://docs.rs/bdk_bitcoind_rpc"
@@ -14,12 +14,12 @@ readme = "README.md"

 [dependencies]
 # For no-std, remember to enable the bitcoin/no-std feature
-bitcoin = { version = "0.31", default-features = false }
-bitcoincore-rpc = { version = "0.18" }
-bdk_chain = { path = "../chain", version = "0.12", default-features = false }
+bitcoin = { version = "0.30", default-features = false }
+bitcoincore-rpc = { version = "0.17" }
+bdk_chain = { path = "../chain", version = "0.6", default-features = false }

 [dev-dependencies]
-bdk_testenv = { path = "../testenv", default_features = false }
+bitcoind = { version = "0.33", features = ["25_0"] }
 anyhow = { version = "1" }

 [features]
--- a/crates/bitcoind_rpc/src/lib.rs
+++ b/crates/bitcoind_rpc/src/lib.rs
@@ -14,7 +14,7 @@ use bitcoin::{block::Header, Block, BlockHash, Transaction};
 pub use bitcoincore_rpc;
 use bitcoincore_rpc::bitcoincore_rpc_json;

-/// The [`Emitter`] is used to emit data sourced from [`bitcoincore_rpc::Client`].
+/// A structure that emits data sourced from [`bitcoincore_rpc::Client`].
 ///
 /// Refer to [module-level documentation] for more.
 ///
@@ -43,13 +43,11 @@ pub struct Emitter<'c, C> {
 }

 impl<'c, C: bitcoincore_rpc::RpcApi> Emitter<'c, C> {
-    /// Construct a new [`Emitter`].
+    /// Construct a new [`Emitter`] with the given RPC `client`, `last_cp` and `start_height`.
    ///
-    /// `last_cp` informs the emitter of the chain we are starting off with. This way, the emitter
-    /// can start emission from a block that connects to the original chain.
-    ///
-    /// `start_height` starts emission from a given height (if there are no conflicts with the
-    /// original chain).
+    /// * `last_cp` is the check point used to find the latest block which is still part of the best
+    ///   chain.
+    /// * `start_height` is the block height to start emitting blocks from.
    pub fn new(client: &'c C, last_cp: CheckPoint, start_height: u32) -> Self {
        Self {
            client,
@@ -129,58 +127,13 @@ impl<'c, C: bitcoincore_rpc::RpcApi> Emitter<'c, C> {
    }

    /// Emit the next block height and header (if any).
-    pub fn next_header(&mut self) -> Result<Option<BlockEvent<Header>>, bitcoincore_rpc::Error> {
-        Ok(poll(self, |hash| self.client.get_block_header(hash))?
-            .map(|(checkpoint, block)| BlockEvent { block, checkpoint }))
+    pub fn next_header(&mut self) -> Result<Option<(u32, Header)>, bitcoincore_rpc::Error> {
+        poll(self, |hash| self.client.get_block_header(hash))
    }

    /// Emit the next block height and block (if any).
-    pub fn next_block(&mut self) -> Result<Option<BlockEvent<Block>>, bitcoincore_rpc::Error> {
-        Ok(poll(self, |hash| self.client.get_block(hash))?
-            .map(|(checkpoint, block)| BlockEvent { block, checkpoint }))
-    }
-}
-
-/// A newly emitted block from [`Emitter`].
-#[derive(Debug)]
-pub struct BlockEvent<B> {
-    /// Either a full [`Block`] or [`Header`] of the new block.
-    pub block: B,
-
-    /// The checkpoint of the new block.
-    ///
-    /// A [`CheckPoint`] is a node of a linked list of [`BlockId`]s. This checkpoint is linked to
-    /// all [`BlockId`]s originally passed in [`Emitter::new`] as well as emitted blocks since then.
-    /// These blocks are guaranteed to be of the same chain.
-    ///
-    /// This is important as BDK structures require block-to-apply to be connected with another
-    /// block in the original chain.
-    pub checkpoint: CheckPoint,
-}
-
-impl<B> BlockEvent<B> {
-    /// The block height of this new block.
-    pub fn block_height(&self) -> u32 {
-        self.checkpoint.height()
-    }
-
-    /// The block hash of this new block.
-    pub fn block_hash(&self) -> BlockHash {
-        self.checkpoint.hash()
-    }
-
-    /// The [`BlockId`] of a previous block that this block connects to.
-    ///
-    /// This either returns a [`BlockId`] of a previously emitted block or from the chain we started
-    /// with (passed in as `last_cp` in [`Emitter::new`]).
-    ///
-    /// This value is derived from [`BlockEvent::checkpoint`].
-    pub fn connected_to(&self) -> BlockId {
-        match self.checkpoint.prev() {
-            Some(prev_cp) => prev_cp.block_id(),
-            // there is no previous checkpoint, so just connect with itself
-            None => self.checkpoint.block_id(),
-        }
+    pub fn next_block(&mut self) -> Result<Option<(u32, Block)>, bitcoincore_rpc::Error> {
+        poll(self, |hash| self.client.get_block(hash))
    }
 }

@@ -250,7 +203,7 @@ where
 fn poll<C, V, F>(
    emitter: &mut Emitter<C>,
    get_item: F,
-) -> Result<Option<(CheckPoint, V)>, bitcoincore_rpc::Error>
+) -> Result<Option<(u32, V)>, bitcoincore_rpc::Error>
 where
    C: bitcoincore_rpc::RpcApi,
    F: Fn(&BlockHash) -> Result<V, bitcoincore_rpc::Error>,
@@ -262,14 +215,13 @@ where
                let hash = res.hash;
                let item = get_item(&hash)?;

-                let new_cp = emitter
+                emitter.last_cp = emitter
                    .last_cp
                    .clone()
                    .push(BlockId { height, hash })
                    .expect("must push");
-                emitter.last_cp = new_cp.clone();
                emitter.last_block = Some(res);
-                return Ok(Some((new_cp, item)));
+                return Ok(Some((height, item)));
            }
            PollResponse::NoMoreBlocks => {
                emitter.last_block = None;
--- a/crates/bitcoind_rpc/tests/test_emitter.rs
+++ b/crates/bitcoind_rpc/tests/test_emitter.rs
@@ -2,14 +2,182 @@ use std::collections::{BTreeMap, BTreeSet};

 use bdk_bitcoind_rpc::Emitter;
 use bdk_chain::{
-    bitcoin::{Address, Amount, Txid},
+    bitcoin::{Address, Amount, BlockHash, Txid},
    keychain::Balance,
    local_chain::{self, CheckPoint, LocalChain},
    Append, BlockId, IndexedTxGraph, SpkTxOutIndex,
 };
-use bdk_testenv::TestEnv;
-use bitcoin::{hashes::Hash, Block, OutPoint, ScriptBuf, WScriptHash};
-use bitcoincore_rpc::RpcApi;
+use bitcoin::{
+    address::NetworkChecked, block::Header, hash_types::TxMerkleNode, hashes::Hash,
+    secp256k1::rand::random, Block, CompactTarget, OutPoint, ScriptBuf, ScriptHash, Transaction,
+    TxIn, TxOut, WScriptHash,
+};
+use bitcoincore_rpc::{
+    bitcoincore_rpc_json::{GetBlockTemplateModes, GetBlockTemplateRules},
+    RpcApi,
+};
+
+struct TestEnv {
+    #[allow(dead_code)]
+    daemon: bitcoind::BitcoinD,
+    client: bitcoincore_rpc::Client,
+}
+
+impl TestEnv {
+    fn new() -> anyhow::Result<Self> {
+        let daemon = match std::env::var_os("TEST_BITCOIND") {
+            Some(bitcoind_path) => bitcoind::BitcoinD::new(bitcoind_path),
+            None => bitcoind::BitcoinD::from_downloaded(),
+        }?;
+        let client = bitcoincore_rpc::Client::new(
+            &daemon.rpc_url(),
+            bitcoincore_rpc::Auth::CookieFile(daemon.params.cookie_file.clone()),
+        )?;
+        Ok(Self { daemon, client })
+    }
+
+    fn mine_blocks(
+        &self,
+        count: usize,
+        address: Option<Address>,
+    ) -> anyhow::Result<Vec<BlockHash>> {
+        let coinbase_address = match address {
+            Some(address) => address,
+            None => self.client.get_new_address(None, None)?.assume_checked(),
+        };
+        let block_hashes = self
+            .client
+            .generate_to_address(count as _, &coinbase_address)?;
+        Ok(block_hashes)
+    }
+
+    fn mine_empty_block(&self) -> anyhow::Result<(usize, BlockHash)> {
+        let bt = self.client.get_block_template(
+            GetBlockTemplateModes::Template,
+            &[GetBlockTemplateRules::SegWit],
+            &[],
+        )?;
+
+        let txdata = vec![Transaction {
+            version: 1,
+            lock_time: bitcoin::absolute::LockTime::from_height(0)?,
+            input: vec![TxIn {
+                previous_output: bitcoin::OutPoint::default(),
+                script_sig: ScriptBuf::builder()
+                    .push_int(bt.height as _)
+                    // randomn number so that re-mining creates unique block
+                    .push_int(random())
+                    .into_script(),
+                sequence: bitcoin::Sequence::default(),
+                witness: bitcoin::Witness::new(),
+            }],
+            output: vec![TxOut {
+                value: 0,
+                script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()),
+            }],
+        }];
+
+        let bits: [u8; 4] = bt
+            .bits
+            .clone()
+            .try_into()
+            .expect("rpc provided us with invalid bits");
+
+        let mut block = Block {
+            header: Header {
+                version: bitcoin::block::Version::default(),
+                prev_blockhash: bt.previous_block_hash,
+                merkle_root: TxMerkleNode::all_zeros(),
+                time: Ord::max(bt.min_time, std::time::UNIX_EPOCH.elapsed()?.as_secs()) as u32,
+                bits: CompactTarget::from_consensus(u32::from_be_bytes(bits)),
+                nonce: 0,
+            },
+            txdata,
+        };
+
+        block.header.merkle_root = block.compute_merkle_root().expect("must compute");
+
+        for nonce in 0..=u32::MAX {
+            block.header.nonce = nonce;
+            if block.header.target().is_met_by(block.block_hash()) {
+                break;
+            }
+        }
+
+        self.client.submit_block(&block)?;
+        Ok((bt.height as usize, block.block_hash()))
+    }
+
+    fn invalidate_blocks(&self, count: usize) -> anyhow::Result<()> {
+        let mut hash = self.client.get_best_block_hash()?;
+        for _ in 0..count {
+            let prev_hash = self.client.get_block_info(&hash)?.previousblockhash;
+            self.client.invalidate_block(&hash)?;
+            match prev_hash {
+                Some(prev_hash) => hash = prev_hash,
+                None => break,
+            }
+        }
+        Ok(())
+    }
+
+    fn reorg(&self, count: usize) -> anyhow::Result<Vec<BlockHash>> {
+        let start_height = self.client.get_block_count()?;
+        self.invalidate_blocks(count)?;
+
+        let res = self.mine_blocks(count, None);
+        assert_eq!(
+            self.client.get_block_count()?,
+            start_height,
+            "reorg should not result in height change"
+        );
+        res
+    }
+
+    fn reorg_empty_blocks(&self, count: usize) -> anyhow::Result<Vec<(usize, BlockHash)>> {
+        let start_height = self.client.get_block_count()?;
+        self.invalidate_blocks(count)?;
+
+        let res = (0..count)
+            .map(|_| self.mine_empty_block())
+            .collect::<Result<Vec<_>, _>>()?;
+        assert_eq!(
+            self.client.get_block_count()?,
+            start_height,
+            "reorg should not result in height change"
+        );
+        Ok(res)
+    }
+
+    fn send(&self, address: &Address<NetworkChecked>, amount: Amount) -> anyhow::Result<Txid> {
+        let txid = self
+            .client
+            .send_to_address(address, amount, None, None, None, None, None, None)?;
+        Ok(txid)
+    }
+}
+
+fn block_to_chain_update(block: &bitcoin::Block, height: u32) -> local_chain::Update {
+    let this_id = BlockId {
+        height,
+        hash: block.block_hash(),
+    };
+    let tip = if block.header.prev_blockhash == BlockHash::all_zeros() {
+        CheckPoint::new(this_id)
+    } else {
+        CheckPoint::new(BlockId {
+            height: height - 1,
+            hash: block.header.prev_blockhash,
+        })
+        .extend(core::iter::once(this_id))
+        .expect("must construct checkpoint")
+    };
+
+    local_chain::Update {
+        tip,
+        introduce_older_blocks: false,
+    }
+}

 /// Ensure that blocks are emitted in order even after reorg.
 ///
@@ -20,56 +188,44 @@ use bitcoincore_rpc::RpcApi;
 #[test]
 pub fn test_sync_local_chain() -> anyhow::Result<()> {
    let env = TestEnv::new()?;
-    let network_tip = env.rpc_client().get_block_count()?;
-    let (mut local_chain, _) = LocalChain::from_genesis_hash(env.rpc_client().get_block_hash(0)?);
-    let mut emitter = Emitter::new(env.rpc_client(), local_chain.tip(), 0);
+    let (mut local_chain, _) = LocalChain::from_genesis_hash(env.client.get_block_hash(0)?);
+    let mut emitter = Emitter::new(&env.client, local_chain.tip(), 0);

-    // Mine some blocks and return the actual block hashes.
-    // Because initializing `ElectrsD` already mines some blocks, we must include those too when
-    // returning block hashes.
+    // mine some blocks and returned the actual block hashes
    let exp_hashes = {
-        let mut hashes = (0..=network_tip)
-            .map(|height| env.rpc_client().get_block_hash(height))
-            .collect::<Result<Vec<_>, _>>()?;
-        hashes.extend(env.mine_blocks(101 - network_tip as usize, None)?);
+        let mut hashes = vec![env.client.get_block_hash(0)?]; // include genesis block
+        hashes.extend(env.mine_blocks(101, None)?);
        hashes
    };

-    // See if the emitter outputs the right blocks.
+    // see if the emitter outputs the right blocks
    println!("first sync:");
-    while let Some(emission) = emitter.next_block()? {
-        let height = emission.block_height();
-        let hash = emission.block_hash();
+    while let Some((height, block)) = emitter.next_block()? {
        assert_eq!(
-            emission.block_hash(),
+            block.block_hash(),
            exp_hashes[height as usize],
            "emitted block hash is unexpected"
        );

+        let chain_update = block_to_chain_update(&block, height);
        assert_eq!(
-            local_chain.apply_update(local_chain::Update {
-                tip: emission.checkpoint,
-                introduce_older_blocks: false,
-            })?,
-            BTreeMap::from([(height, Some(hash))]),
+            local_chain.apply_update(chain_update)?,
+            BTreeMap::from([(height, Some(block.block_hash()))]),
            "chain update changeset is unexpected",
        );
    }

    assert_eq!(
-        local_chain
-            .iter_checkpoints()
-            .map(|cp| (cp.height(), cp.hash()))
-            .collect::<BTreeSet<_>>(),
-        exp_hashes
+        local_chain.blocks(),
+        &exp_hashes
            .iter()
            .enumerate()
            .map(|(i, hash)| (i as u32, *hash))
-            .collect::<BTreeSet<_>>(),
+            .collect(),
        "final local_chain state is unexpected",
    );

-    // Perform reorg.
+    // perform reorg
    let reorged_blocks = env.reorg(6)?;
    let exp_hashes = exp_hashes
        .iter()
@@ -78,33 +234,30 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
        .cloned()
        .collect::<Vec<_>>();

-    // See if the emitter outputs the right blocks.
+    // see if the emitter outputs the right blocks
    println!("after reorg:");
    let mut exp_height = exp_hashes.len() - reorged_blocks.len();
-    while let Some(emission) = emitter.next_block()? {
-        let height = emission.block_height();
-        let hash = emission.block_hash();
+    while let Some((height, block)) = emitter.next_block()? {
        assert_eq!(
            height, exp_height as u32,
            "emitted block has unexpected height"
        );

        assert_eq!(
-            hash, exp_hashes[height as usize],
+            block.block_hash(),
+            exp_hashes[height as usize],
            "emitted block is unexpected"
        );

+        let chain_update = block_to_chain_update(&block, height);
        assert_eq!(
-            local_chain.apply_update(local_chain::Update {
-                tip: emission.checkpoint,
-                introduce_older_blocks: false,
-            })?,
+            local_chain.apply_update(chain_update)?,
            if exp_height == exp_hashes.len() - reorged_blocks.len() {
-                core::iter::once((height, Some(hash)))
+                core::iter::once((height, Some(block.block_hash())))
                    .chain((height + 1..exp_hashes.len() as u32).map(|h| (h, None)))
                    .collect::<bdk_chain::local_chain::ChangeSet>()
            } else {
-                BTreeMap::from([(height, Some(hash))])
+                BTreeMap::from([(height, Some(block.block_hash()))])
            },
            "chain update changeset is unexpected",
        );
@@ -113,15 +266,12 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
    }

    assert_eq!(
-        local_chain
-            .iter_checkpoints()
-            .map(|cp| (cp.height(), cp.hash()))
-            .collect::<BTreeSet<_>>(),
-        exp_hashes
+        local_chain.blocks(),
+        &exp_hashes
            .iter()
            .enumerate()
            .map(|(i, hash)| (i as u32, *hash))
-            .collect::<BTreeSet<_>>(),
+            .collect(),
        "final local_chain state is unexpected after reorg",
    );

@@ -137,25 +287,16 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
    let env = TestEnv::new()?;

    println!("getting new addresses!");
-    let addr_0 = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
-    let addr_1 = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
-    let addr_2 = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
+    let addr_0 = env.client.get_new_address(None, None)?.assume_checked();
+    let addr_1 = env.client.get_new_address(None, None)?.assume_checked();
+    let addr_2 = env.client.get_new_address(None, None)?.assume_checked();
    println!("got new addresses!");

    println!("mining block!");
    env.mine_blocks(101, None)?;
    println!("mined blocks!");

-    let (mut chain, _) = LocalChain::from_genesis_hash(env.rpc_client().get_block_hash(0)?);
+    let (mut chain, _) = LocalChain::from_genesis_hash(env.client.get_block_hash(0)?);
    let mut indexed_tx_graph = IndexedTxGraph::<BlockId, _>::new({
        let mut index = SpkTxOutIndex::<usize>::default();
        index.insert_spk(0, addr_0.script_pubkey());
@@ -164,15 +305,11 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
        index
    });

-    let emitter = &mut Emitter::new(env.rpc_client(), chain.tip(), 0);
+    let emitter = &mut Emitter::new(&env.client, chain.tip(), 0);

-    while let Some(emission) = emitter.next_block()? {
-        let height = emission.block_height();
-        let _ = chain.apply_update(local_chain::Update {
-            tip: emission.checkpoint,
-            introduce_older_blocks: false,
-        })?;
-        let indexed_additions = indexed_tx_graph.apply_block_relevant(&emission.block, height);
+    while let Some((height, block)) = emitter.next_block()? {
+        let _ = chain.apply_update(block_to_chain_update(&block, height))?;
+        let indexed_additions = indexed_tx_graph.apply_block_relevant(block, height);
        assert!(indexed_additions.is_empty());
    }

@@ -180,7 +317,7 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
    let exp_txids = {
        let mut txids = BTreeSet::new();
        for _ in 0..3 {
-            txids.insert(env.rpc_client().send_to_address(
+            txids.insert(env.client.send_to_address(
                &addr_0,
                Amount::from_sat(10_000),
                None,
@@ -216,7 +353,7 @@ fn test_into_tx_graph() -> anyhow::Result<()> {

    // mine a block that confirms the 3 txs
    let exp_block_hash = env.mine_blocks(1, None)?[0];
-    let exp_block_height = env.rpc_client().get_block_info(&exp_block_hash)?.height as u32;
+    let exp_block_height = env.client.get_block_info(&exp_block_hash)?.height as u32;
    let exp_anchors = exp_txids
        .iter()
        .map({
@@ -230,13 +367,10 @@ fn test_into_tx_graph() -> anyhow::Result<()> {

    // must receive mined block which will confirm the transactions.
    {
-        let emission = emitter.next_block()?.expect("must get mined block");
-        let height = emission.block_height();
-        let _ = chain.apply_update(local_chain::Update {
-            tip: emission.checkpoint,
-            introduce_older_blocks: false,
-        })?;
-        let indexed_additions = indexed_tx_graph.apply_block_relevant(&emission.block, height);
+        let (height, block) = emitter.next_block()?.expect("must get mined block");
+        let _ = chain
+            .apply_update(CheckPoint::from_header(&block.header, height).into_update(false))?;
+        let indexed_additions = indexed_tx_graph.apply_block_relevant(block, height);
        assert!(indexed_additions.graph.txs.is_empty());
        assert!(indexed_additions.graph.txouts.is_empty());
        assert_eq!(indexed_additions.graph.anchors, exp_anchors);
@@ -260,10 +394,10 @@ fn ensure_block_emitted_after_reorg_is_at_reorg_height() -> anyhow::Result<()> {

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        EMITTER_START_HEIGHT as _,
    );
@@ -273,12 +407,9 @@ fn ensure_block_emitted_after_reorg_is_at_reorg_height() -> anyhow::Result<()> {

    for reorg_count in 1..=10 {
        let replaced_blocks = env.reorg_empty_blocks(reorg_count)?;
-        let next_emission = emitter.next_header()?.expect("must emit block after reorg");
+        let (height, next_header) = emitter.next_header()?.expect("must emit block after reorg");
        assert_eq!(
-            (
-                next_emission.block_height() as usize,
-                next_emission.block_hash()
-            ),
+            (height as usize, next_header.block_hash()),
            replaced_blocks[0],
            "block emitted after reorg should be at the reorg height"
        );
@@ -308,9 +439,8 @@ fn sync_from_emitter<C>(
 where
    C: bitcoincore_rpc::RpcApi,
 {
-    while let Some(emission) = emitter.next_block()? {
-        let height = emission.block_height();
-        process_block(recv_chain, recv_graph, emission.block, height)?;
+    while let Some((height, block)) = emitter.next_block()? {
+        process_block(recv_chain, recv_graph, block, height)?;
    }
    Ok(())
 }
@@ -337,24 +467,21 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        0,
    );

    // setup addresses
-    let addr_to_mine = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
-    let spk_to_track = ScriptBuf::new_p2wsh(&WScriptHash::all_zeros());
+    let addr_to_mine = env.client.get_new_address(None, None)?.assume_checked();
+    let spk_to_track = ScriptBuf::new_v0_p2wsh(&WScriptHash::all_zeros());
    let addr_to_track = Address::from_script(&spk_to_track, bitcoin::Network::Regtest)?;

    // setup receiver
-    let (mut recv_chain, _) = LocalChain::from_genesis_hash(env.rpc_client().get_block_hash(0)?);
+    let (mut recv_chain, _) = LocalChain::from_genesis_hash(env.client.get_block_hash(0)?);
    let mut recv_graph = IndexedTxGraph::<BlockId, _>::new({
        let mut recv_index = SpkTxOutIndex::default();
        recv_index.insert_spk((), spk_to_track.clone());
@@ -370,7 +497,7 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {

        // lock outputs that send to `addr_to_track`
        let outpoints_to_lock = env
-            .rpc_client()
+            .client
            .get_transaction(&txid, None)?
            .transaction()?
            .output
@@ -379,7 +506,7 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {
            .filter(|(_, txo)| txo.script_pubkey == spk_to_track)
            .map(|(vout, _)| OutPoint::new(txid, vout as _))
            .collect::<Vec<_>>();
-        env.rpc_client().lock_unspent(&outpoints_to_lock)?;
+        env.client.lock_unspent(&outpoints_to_lock)?;

        let _ = env.mine_blocks(1, None)?;
    }
@@ -428,19 +555,16 @@ fn mempool_avoids_re_emission() -> anyhow::Result<()> {

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        0,
    );

    // mine blocks and sync up emitter
-    let addr = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
+    let addr = env.client.get_new_address(None, None)?.assume_checked();
    env.mine_blocks(BLOCKS_TO_MINE, Some(addr.clone()))?;
    while emitter.next_header()?.is_some() {}

@@ -493,19 +617,16 @@ fn mempool_re_emits_if_tx_introduction_height_not_reached() -> anyhow::Result<()

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        0,
    );

    // mine blocks to get initial balance, sync emitter up to tip
-    let addr = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
+    let addr = env.client.get_new_address(None, None)?.assume_checked();
    env.mine_blocks(PREMINE_COUNT, Some(addr.clone()))?;
    while emitter.next_header()?.is_some() {}

@@ -539,8 +660,7 @@ fn mempool_re_emits_if_tx_introduction_height_not_reached() -> anyhow::Result<()

    // At this point, the emitter has seen all mempool transactions. It should only re-emit those
    // that have introduction heights less than the emitter's last-emitted block tip.
-    while let Some(emission) = emitter.next_header()? {
-        let height = emission.block_height();
+    while let Some((height, _)) = emitter.next_header()? {
        // We call `mempool()` twice.
        // The second call (at height `h`) should skip the tx introduced at height `h`.
        for try_index in 0..2 {
@@ -581,19 +701,16 @@ fn mempool_during_reorg() -> anyhow::Result<()> {

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        0,
    );

    // mine blocks to get initial balance
-    let addr = env
-        .rpc_client()
-        .get_new_address(None, None)?
-        .assume_checked();
+    let addr = env.client.get_new_address(None, None)?.assume_checked();
    env.mine_blocks(PREMINE_COUNT, Some(addr.clone()))?;

    // introduce mempool tx at each block extension
@@ -611,7 +728,7 @@ fn mempool_during_reorg() -> anyhow::Result<()> {
            .into_iter()
            .map(|(tx, _)| tx.txid())
            .collect::<BTreeSet<_>>(),
-        env.rpc_client()
+        env.client
            .get_raw_mempool()?
            .into_iter()
            .collect::<BTreeSet<_>>(),
@@ -630,15 +747,14 @@ fn mempool_during_reorg() -> anyhow::Result<()> {
        // emission.
        // TODO: How can have have reorg logic in `TestEnv` NOT blacklast old blocks first?
        let tx_introductions = dbg!(env
-            .rpc_client()
+            .client
            .get_raw_mempool_verbose()?
            .into_iter()
            .map(|(txid, entry)| (txid, entry.height as usize))
            .collect::<BTreeMap<_, _>>());

        // `next_header` emits the replacement block of the reorg
-        if let Some(emission) = emitter.next_header()? {
-            let height = emission.block_height();
+        if let Some((height, _)) = emitter.next_header()? {
            println!("\t- replacement height: {}", height);

            // the mempool emission (that follows the first block emission after reorg) should only
@@ -707,10 +823,10 @@ fn no_agreement_point() -> anyhow::Result<()> {

    // start height is 99
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        (PREMINE_COUNT - 2) as u32,
    );
@@ -719,27 +835,27 @@ fn no_agreement_point() -> anyhow::Result<()> {
    env.mine_blocks(PREMINE_COUNT, None)?;

    // emit block 99a
-    let block_header_99a = emitter.next_header()?.expect("block 99a header").block;
+    let (_, block_header_99a) = emitter.next_header()?.expect("block 99a header");
    let block_hash_99a = block_header_99a.block_hash();
    let block_hash_98a = block_header_99a.prev_blockhash;

    // emit block 100a
-    let block_header_100a = emitter.next_header()?.expect("block 100a header").block;
+    let (_, block_header_100a) = emitter.next_header()?.expect("block 100a header");
    let block_hash_100a = block_header_100a.block_hash();

    // get hash for block 101a
-    let block_hash_101a = env.rpc_client().get_block_hash(101)?;
+    let block_hash_101a = env.client.get_block_hash(101)?;

    // invalidate blocks 99a, 100a, 101a
-    env.rpc_client().invalidate_block(&block_hash_99a)?;
-    env.rpc_client().invalidate_block(&block_hash_100a)?;
-    env.rpc_client().invalidate_block(&block_hash_101a)?;
+    env.client.invalidate_block(&block_hash_99a)?;
+    env.client.invalidate_block(&block_hash_100a)?;
+    env.client.invalidate_block(&block_hash_101a)?;

    // mine new blocks 99b, 100b, 101b
    env.mine_blocks(3, None)?;

    // emit block header 99b
-    let block_header_99b = emitter.next_header()?.expect("block 99b header").block;
+    let (_, block_header_99b) = emitter.next_header()?.expect("block 99b header");
    let block_hash_99b = block_header_99b.block_hash();
    let block_hash_98b = block_header_99b.prev_blockhash;

--- a/crates/chain/Cargo.toml
+++ b/crates/chain/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "bdk_chain"
-version = "0.12.0"
+version = "0.6.0"
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.57"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
 documentation = "https://docs.rs/bdk_chain"
@@ -14,16 +14,16 @@ readme = "README.md"

 [dependencies]
 # For no-std, remember to enable the bitcoin/no-std feature
-bitcoin = { version = "0.31.0", default-features = false }
-serde_crate = { package = "serde", version = "1", optional = true, features = ["derive", "rc"] }
+bitcoin = { version = "0.30.0", default-features = false }
+serde_crate = { package = "serde", version = "1", optional = true, features = ["derive"] }

 # Use hashbrown as a feature flag to have HashSet and HashMap from it.
+# note versions > 0.9.1 breaks ours 1.57.0 MSRV.
 hashbrown = { version = "0.9.1", optional = true, features = ["serde"] }
-miniscript = { version = "11.0.0", optional = true, default-features = false }
+miniscript = { version = "10.0.0", optional = true, default-features = false }

 [dev-dependencies]
 rand = "0.8"
-proptest = "1.2.0"

 [features]
 default = ["std"]
--- a/crates/chain/src/chain_data.rs
+++ b/crates/chain/src/chain_data.rs
@@ -9,7 +9,7 @@ use crate::{Anchor, AnchorFromBlockPosition, COINBASE_MATURITY};
 pub enum ChainPosition<A> {
    /// The chain data is seen as confirmed, and in anchored by `A`.
    Confirmed(A),
-    /// The chain data is not confirmed and last seen in the mempool at this timestamp.
+    /// The chain data is seen in mempool at this given timestamp.
    Unconfirmed(u64),
 }

@@ -48,14 +48,14 @@ impl<A: Anchor> ChainPosition<A> {
    serde(crate = "serde_crate")
 )]
 pub enum ConfirmationTime {
-    /// The transaction is confirmed
+    /// The confirmed variant.
    Confirmed {
        /// Confirmation height.
        height: u32,
        /// Confirmation time in unix seconds.
        time: u64,
    },
-    /// The transaction is unconfirmed
+    /// The unconfirmed variant.
    Unconfirmed {
        /// The last-seen timestamp in unix seconds.
        last_seen: u64,
@@ -81,7 +81,7 @@ impl From<ChainPosition<ConfirmationTimeHeightAnchor>> for ConfirmationTime {
                height: a.confirmation_height,
                time: a.confirmation_time,
            },
-            ChainPosition::Unconfirmed(last_seen) => Self::Unconfirmed { last_seen },
+            ChainPosition::Unconfirmed(_) => Self::Unconfirmed { last_seen: 0 },
        }
    }
 }
@@ -147,8 +147,6 @@ impl From<(&u32, &BlockHash)> for BlockId {

 /// An [`Anchor`] implementation that also records the exact confirmation height of the transaction.
 ///
-/// Note that the confirmation block and the anchor block can be different here.
-///
 /// Refer to [`Anchor`] for more details.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
 #[cfg_attr(
@@ -157,12 +155,13 @@ impl From<(&u32, &BlockHash)> for BlockId {
    serde(crate = "serde_crate")
 )]
 pub struct ConfirmationHeightAnchor {
+    /// The anchor block.
+    pub anchor_block: BlockId,
+
    /// The exact confirmation height of the transaction.
    ///
    /// It is assumed that this value is never larger than the height of the anchor block.
    pub confirmation_height: u32,
-    /// The anchor block.
-    pub anchor_block: BlockId,
 }

 impl Anchor for ConfirmationHeightAnchor {
@@ -187,8 +186,6 @@ impl AnchorFromBlockPosition for ConfirmationHeightAnchor {
 /// An [`Anchor`] implementation that also records the exact confirmation time and height of the
 /// transaction.
 ///
-/// Note that the confirmation block and the anchor block can be different here.
-///
 /// Refer to [`Anchor`] for more details.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
 #[cfg_attr(
@@ -197,12 +194,12 @@ impl AnchorFromBlockPosition for ConfirmationHeightAnchor {
    serde(crate = "serde_crate")
 )]
 pub struct ConfirmationTimeHeightAnchor {
-    /// The confirmation height of the transaction being anchored.
-    pub confirmation_height: u32,
-    /// The confirmation time of the transaction being anchored.
-    pub confirmation_time: u64,
    /// The anchor block.
    pub anchor_block: BlockId,
+    /// The confirmation height of the chain data being anchored.
+    pub confirmation_height: u32,
+    /// The confirmation time of the chain data being anchored.
+    pub confirmation_time: u64,
 }

 impl Anchor for ConfirmationTimeHeightAnchor {
@@ -228,12 +225,12 @@ impl AnchorFromBlockPosition for ConfirmationTimeHeightAnchor {
 /// A `TxOut` with as much data as we can retrieve about it
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct FullTxOut<A> {
-    /// The position of the transaction in `outpoint` in the overall chain.
-    pub chain_position: ChainPosition<A>,
    /// The location of the `TxOut`.
    pub outpoint: OutPoint,
    /// The `TxOut`.
    pub txout: TxOut,
+    /// The position of the transaction in `outpoint` in the overall chain.
+    pub chain_position: ChainPosition<A>,
    /// The txid and chain position of the transaction (if any) that has spent this output.
    pub spent_by: Option<(ChainPosition<A>, Txid)>,
    /// Whether this output is on a coinbase transaction.
@@ -298,35 +295,3 @@ impl<A: Anchor> FullTxOut<A> {
        true
    }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn chain_position_ord() {
-        let unconf1 = ChainPosition::<ConfirmationHeightAnchor>::Unconfirmed(10);
-        let unconf2 = ChainPosition::<ConfirmationHeightAnchor>::Unconfirmed(20);
-        let conf1 = ChainPosition::Confirmed(ConfirmationHeightAnchor {
-            confirmation_height: 9,
-            anchor_block: BlockId {
-                height: 20,
-                ..Default::default()
-            },
-        });
-        let conf2 = ChainPosition::Confirmed(ConfirmationHeightAnchor {
-            confirmation_height: 12,
-            anchor_block: BlockId {
-                height: 15,
-                ..Default::default()
-            },
-        });
-
-        assert!(unconf2 > unconf1, "higher last_seen means higher ord");
-        assert!(unconf1 > conf1, "unconfirmed is higher ord than confirmed");
-        assert!(
-            conf2 > conf1,
-            "confirmation_height is higher then it should be higher ord"
-        );
-    }
-}
--- a/crates/chain/src/chain_oracle.rs
+++ b/crates/chain/src/chain_oracle.rs
@@ -3,7 +3,7 @@ use crate::BlockId;
 /// Represents a service that tracks the blockchain.
 ///
 /// The main method is [`is_block_in_chain`] which determines whether a given block of [`BlockId`]
-/// is an ancestor of the `chain_tip`.
+/// is an ancestor of another "static block".
 ///
 /// [`is_block_in_chain`]: Self::is_block_in_chain
 pub trait ChainOracle {
--- a/crates/chain/src/indexed_tx_graph.rs
+++ b/crates/chain/src/indexed_tx_graph.rs
@@ -1,5 +1,7 @@
-//! Contains the [`IndexedTxGraph`] and associated types. Refer to the
-//! [`IndexedTxGraph`] documentation for more.
+//! Contains the [`IndexedTxGraph`] structure and associated types.
+//!
+//! This is essentially a [`TxGraph`] combined with an indexer.
+
 use alloc::vec::Vec;
 use bitcoin::{Block, OutPoint, Transaction, TxOut, Txid};

@@ -9,9 +11,9 @@ use crate::{
    Anchor, AnchorFromBlockPosition, Append, BlockId,
 };

-/// The [`IndexedTxGraph`] combines a [`TxGraph`] and an [`Indexer`] implementation.
+/// A struct that combines [`TxGraph`] and an [`Indexer`] implementation.
 ///
-/// It ensures that [`TxGraph`] and [`Indexer`] are updated atomically.
+/// This structure ensures that [`TxGraph`] and [`Indexer`] are updated atomically.
 #[derive(Debug)]
 pub struct IndexedTxGraph<A, I> {
    /// Transaction index.
@@ -224,26 +226,20 @@ where
    /// Irrelevant transactions in `txs` will be ignored.
    pub fn apply_block_relevant(
        &mut self,
-        block: &Block,
+        block: Block,
        height: u32,
    ) -> ChangeSet<A, I::ChangeSet> {
        let block_id = BlockId {
            hash: block.block_hash(),
            height,
        };
-        let mut changeset = ChangeSet::<A, I::ChangeSet>::default();
-        for (tx_pos, tx) in block.txdata.iter().enumerate() {
-            changeset.indexer.append(self.index.index_tx(tx));
-            if self.index.is_tx_relevant(tx) {
-                let txid = tx.txid();
-                let anchor = A::from_block_position(block, block_id, tx_pos);
-                changeset.graph.append(self.graph.insert_tx(tx.clone()));
-                changeset
-                    .graph
-                    .append(self.graph.insert_anchor(txid, anchor));
-            }
-        }
-        changeset
+        let txs = block.txdata.iter().enumerate().map(|(tx_pos, tx)| {
+            (
+                tx,
+                core::iter::once(A::from_block_position(&block, block_id, tx_pos)),
+            )
+        });
+        self.batch_insert_relevant(txs)
    }

    /// Batch insert all transactions of the given `block` of `height`.
@@ -270,7 +266,7 @@ where
    }
 }

-/// Represents changes to an [`IndexedTxGraph`].
+/// A structure that represents changes to an [`IndexedTxGraph`].
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(
    feature = "serde",
--- a/crates/chain/src/keychain.rs
+++ b/crates/chain/src/keychain.rs
@@ -20,7 +20,7 @@ pub use txout_index::*;
 /// Represents updates to the derivation index of a [`KeychainTxOutIndex`].
 /// It maps each keychain `K` to its last revealed index.
 ///
-/// It can be applied to [`KeychainTxOutIndex`] with [`apply_changeset`]. [`ChangeSet`]s are
+/// It can be applied to [`KeychainTxOutIndex`] with [`apply_changeset`]. [`ChangeSet] are
 /// monotone in that they will never decrease the revealed derivation index.
 ///
 /// [`KeychainTxOutIndex`]: crate::keychain::KeychainTxOutIndex
@@ -58,9 +58,8 @@ impl<K: Ord> Append for ChangeSet<K> {
                *index = other_index.max(*index);
            }
        });
-        // We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
-        // Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
-        self.0.extend(other.0);
+
+        self.0.append(&mut other.0);
    }

    /// Returns whether the changeset are empty.
--- a/crates/chain/src/keychain/txout_index.rs
+++ b/crates/chain/src/keychain/txout_index.rs
@@ -5,56 +5,23 @@ use crate::{
    spk_iter::BIP32_MAX_INDEX,
    SpkIterator, SpkTxOutIndex,
 };
-use bitcoin::{OutPoint, Script, Transaction, TxOut, Txid};
-use core::{
-    fmt::Debug,
-    ops::{Bound, RangeBounds},
-};
+use alloc::vec::Vec;
+use bitcoin::{OutPoint, Script, TxOut};
+use core::{fmt::Debug, ops::Deref};

 use crate::Append;

-const DEFAULT_LOOKAHEAD: u32 = 25;
-
-/// [`KeychainTxOutIndex`] controls how script pubkeys are revealed for multiple keychains, and
-/// indexes [`TxOut`]s with them.
+/// A convenient wrapper around [`SpkTxOutIndex`] that relates script pubkeys to miniscript public
+/// [`Descriptor`]s.
 ///
-/// A single keychain is a chain of script pubkeys derived from a single [`Descriptor`]. Keychains
-/// are identified using the `K` generic. Script pubkeys are identified by the keychain that they
-/// are derived from `K`, as well as the derivation index `u32`.
+/// Descriptors are referenced by the provided keychain generic (`K`).
 ///
-/// # Revealed script pubkeys
+/// Script pubkeys for a descriptor are revealed chronologically from index 0. I.e., If the last
+/// revealed index of a descriptor is 5; scripts of indices 0 to 4 are guaranteed to be already
+/// revealed. In addition to revealed scripts, we have a `lookahead` parameter for each keychain,
+/// which defines the number of script pubkeys to store ahead of the last revealed index.
 ///
-/// Tracking how script pubkeys are revealed is useful for collecting chain data. For example, if
-/// the user has requested 5 script pubkeys (to receive money with), we only need to use those
-/// script pubkeys to scan for chain data.
-///
-/// Call [`reveal_to_target`] or [`reveal_next_spk`] to reveal more script pubkeys.
-/// Call [`revealed_keychain_spks`] or [`revealed_spks`] to iterate through revealed script pubkeys.
-///
-/// # Lookahead script pubkeys
-///
-/// When an user first recovers a wallet (i.e. from a recovery phrase and/or descriptor), we will
-/// NOT have knowledge of which script pubkeys are revealed. So when we index a transaction or
-/// txout (using [`index_tx`]/[`index_txout`]) we scan the txouts against script pubkeys derived
-/// above the last revealed index. These additionally-derived script pubkeys are called the
-/// lookahead.
-///
-/// The [`KeychainTxOutIndex`] is constructed with the `lookahead` and cannot be altered. The
-/// default `lookahead` count is 1000. Use [`new`] to set a custom `lookahead`.
-///
-/// # Unbounded script pubkey iterator
-///
-/// For script-pubkey-based chain sources (such as Electrum/Esplora), an initial scan is best done
-/// by iterating though derived script pubkeys one by one and requesting transaction histories for
-/// each script pubkey. We will stop after x-number of script pubkeys have empty histories. An
-/// unbounded script pubkey iterator is useful to pass to such a chain source.
-///
-/// Call [`unbounded_spk_iter`] to get an unbounded script pubkey iterator for a given keychain.
-/// Call [`all_unbounded_spk_iters`] to get unbounded script pubkey iterators for all keychains.
-///
-/// # Change sets
-///
-/// Methods that can update the last revealed index will return [`super::ChangeSet`] to report
+/// Methods that could update the last revealed index will return [`super::ChangeSet`] to report
 /// these changes. This can be persisted for future recovery.
 ///
 /// ## Synopsis
@@ -79,7 +46,7 @@ const DEFAULT_LOOKAHEAD: u32 = 25;
 /// # let secp = bdk_chain::bitcoin::secp256k1::Secp256k1::signing_only();
 /// # let (external_descriptor,_) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/0/*)").unwrap();
 /// # let (internal_descriptor,_) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/1/*)").unwrap();
-/// # let (descriptor_for_user_42, _) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/2/*)").unwrap();
+/// # let descriptor_for_user_42 = external_descriptor.clone();
 /// txout_index.add_keychain(MyKeychain::External, external_descriptor);
 /// txout_index.add_keychain(MyKeychain::Internal, internal_descriptor);
 /// txout_index.add_keychain(MyKeychain::MyAppUser { user_id: 42 }, descriptor_for_user_42);
@@ -90,15 +57,6 @@ const DEFAULT_LOOKAHEAD: u32 = 25;
 /// [`Ord`]: core::cmp::Ord
 /// [`SpkTxOutIndex`]: crate::spk_txout_index::SpkTxOutIndex
 /// [`Descriptor`]: crate::miniscript::Descriptor
-/// [`reveal_to_target`]: KeychainTxOutIndex::reveal_to_target
-/// [`reveal_next_spk`]: KeychainTxOutIndex::reveal_next_spk
-/// [`revealed_keychain_spks`]: KeychainTxOutIndex::revealed_keychain_spks
-/// [`revealed_spks`]: KeychainTxOutIndex::revealed_spks
-/// [`index_tx`]: KeychainTxOutIndex::index_tx
-/// [`index_txout`]: KeychainTxOutIndex::index_txout
-/// [`new`]: KeychainTxOutIndex::new
-/// [`unbounded_spk_iter`]: KeychainTxOutIndex::unbounded_spk_iter
-/// [`all_unbounded_spk_iters`]: KeychainTxOutIndex::all_unbounded_spk_iters
 #[derive(Clone, Debug)]
 pub struct KeychainTxOutIndex<K> {
    inner: SpkTxOutIndex<(K, u32)>,
@@ -107,12 +65,25 @@ pub struct KeychainTxOutIndex<K> {
    // last revealed indexes
    last_revealed: BTreeMap<K, u32>,
    // lookahead settings for each keychain
-    lookahead: u32,
+    lookahead: BTreeMap<K, u32>,
 }

 impl<K> Default for KeychainTxOutIndex<K> {
    fn default() -> Self {
-        Self::new(DEFAULT_LOOKAHEAD)
+        Self {
+            inner: SpkTxOutIndex::default(),
+            keychains: BTreeMap::default(),
+            last_revealed: BTreeMap::default(),
+            lookahead: BTreeMap::default(),
+        }
+    }
+}
+
+impl<K> Deref for KeychainTxOutIndex<K> {
+    type Target = SpkTxOutIndex<(K, u32)>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
    }
 }

@@ -143,37 +114,12 @@ impl<K: Clone + Ord + Debug> Indexer for KeychainTxOutIndex<K> {
    }

    fn is_tx_relevant(&self, tx: &bitcoin::Transaction) -> bool {
-        self.inner.is_relevant(tx)
+        self.is_relevant(tx)
    }
 }

-impl<K> KeychainTxOutIndex<K> {
-    /// Construct a [`KeychainTxOutIndex`] with the given `lookahead`.
-    ///
-    /// The `lookahead` is the number of script pubkeys to derive and cache from the internal
-    /// descriptors over and above the last revealed script index. Without a lookahead the index
-    /// will miss outputs you own when processing transactions whose output script pubkeys lie
-    /// beyond the last revealed index. In certain situations, such as when performing an initial
-    /// scan of the blockchain during wallet import, it may be uncertain or unknown what the index
-    /// of the last revealed script pubkey actually is.
-    ///
-    /// Refer to [struct-level docs](KeychainTxOutIndex) for more about `lookahead`.
-    pub fn new(lookahead: u32) -> Self {
-        Self {
-            inner: SpkTxOutIndex::default(),
-            keychains: BTreeMap::new(),
-            last_revealed: BTreeMap::new(),
-            lookahead,
-        }
-    }
-}
-
-/// Methods that are *re-exposed* from the internal [`SpkTxOutIndex`].
 impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    /// Return a reference to the internal [`SpkTxOutIndex`].
-    ///
-    /// **WARNING:** The internal index will contain lookahead spks. Refer to
-    /// [struct-level docs](KeychainTxOutIndex) for more about `lookahead`.
    pub fn inner(&self) -> &SpkTxOutIndex<(K, u32)> {
        &self.inner
    }
@@ -183,116 +129,7 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
        self.inner.outpoints()
    }

-    /// Iterate over known txouts that spend to tracked script pubkeys.
-    pub fn txouts(
-        &self,
-    ) -> impl DoubleEndedIterator<Item = (K, u32, OutPoint, &TxOut)> + ExactSizeIterator {
-        self.inner
-            .txouts()
-            .map(|((k, i), op, txo)| (k.clone(), *i, op, txo))
-    }
-
-    /// Finds all txouts on a transaction that has previously been scanned and indexed.
-    pub fn txouts_in_tx(
-        &self,
-        txid: Txid,
-    ) -> impl DoubleEndedIterator<Item = (K, u32, OutPoint, &TxOut)> {
-        self.inner
-            .txouts_in_tx(txid)
-            .map(|((k, i), op, txo)| (k.clone(), *i, op, txo))
-    }
-
-    /// Return the [`TxOut`] of `outpoint` if it has been indexed.
-    ///
-    /// The associated keychain and keychain index of the txout's spk is also returned.
-    ///
-    /// This calls [`SpkTxOutIndex::txout`] internally.
-    pub fn txout(&self, outpoint: OutPoint) -> Option<(K, u32, &TxOut)> {
-        self.inner
-            .txout(outpoint)
-            .map(|((k, i), txo)| (k.clone(), *i, txo))
-    }
-
-    /// Return the script that exists under the given `keychain`'s `index`.
-    ///
-    /// This calls [`SpkTxOutIndex::spk_at_index`] internally.
-    pub fn spk_at_index(&self, keychain: K, index: u32) -> Option<&Script> {
-        self.inner.spk_at_index(&(keychain, index))
-    }
-
-    /// Returns the keychain and keychain index associated with the spk.
-    ///
-    /// This calls [`SpkTxOutIndex::index_of_spk`] internally.
-    pub fn index_of_spk(&self, script: &Script) -> Option<(K, u32)> {
-        self.inner.index_of_spk(script).cloned()
-    }
-
-    /// Returns whether the spk under the `keychain`'s `index` has been used.
-    ///
-    /// Here, "unused" means that after the script pubkey was stored in the index, the index has
-    /// never scanned a transaction output with it.
-    ///
-    /// This calls [`SpkTxOutIndex::is_used`] internally.
-    pub fn is_used(&self, keychain: K, index: u32) -> bool {
-        self.inner.is_used(&(keychain, index))
-    }
-
-    /// Marks the script pubkey at `index` as used even though the tracker hasn't seen an output
-    /// with it.
-    ///
-    /// This only has an effect when the `index` had been added to `self` already and was unused.
-    ///
-    /// Returns whether the `index` was initially present as `unused`.
-    ///
-    /// This is useful when you want to reserve a script pubkey for something but don't want to add
-    /// the transaction output using it to the index yet. Other callers will consider `index` on
-    /// `keychain` used until you call [`unmark_used`].
-    ///
-    /// This calls [`SpkTxOutIndex::mark_used`] internally.
-    ///
-    /// [`unmark_used`]: Self::unmark_used
-    pub fn mark_used(&mut self, keychain: K, index: u32) -> bool {
-        self.inner.mark_used(&(keychain, index))
-    }
-
-    /// Undoes the effect of [`mark_used`]. Returns whether the `index` is inserted back into
-    /// `unused`.
-    ///
-    /// Note that if `self` has scanned an output with this script pubkey, then this will have no
-    /// effect.
-    ///
-    /// This calls [`SpkTxOutIndex::unmark_used`] internally.
-    ///
-    /// [`mark_used`]: Self::mark_used
-    pub fn unmark_used(&mut self, keychain: K, index: u32) -> bool {
-        self.inner.unmark_used(&(keychain, index))
-    }
-
-    /// Computes total input value going from script pubkeys in the index (sent) and the total output
-    /// value going to script pubkeys in the index (received) in `tx`. For the `sent` to be computed
-    /// correctly, the output being spent must have already been scanned by the index. Calculating
-    /// received just uses the [`Transaction`] outputs directly, so it will be correct even if it has
-    /// not been scanned.
-    ///
-    /// This calls [`SpkTxOutIndex::sent_and_received`] internally.
-    pub fn sent_and_received(&self, tx: &Transaction) -> (u64, u64) {
-        self.inner.sent_and_received(tx)
-    }
-
-    /// Computes the net value that this transaction gives to the script pubkeys in the index and
-    /// *takes* from the transaction outputs in the index. Shorthand for calling
-    /// [`sent_and_received`] and subtracting sent from received.
-    ///
-    /// This calls [`SpkTxOutIndex::net_value`] internally.
-    ///
-    /// [`sent_and_received`]: Self::sent_and_received
-    pub fn net_value(&self, tx: &Transaction) -> i64 {
-        self.inner.net_value(tx)
-    }
-}
-
-impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
-    /// Return a reference to the internal map of keychain to descriptors.
+    /// Return a reference to the internal map of the keychain to descriptors.
    pub fn keychains(&self) -> &BTreeMap<K, Descriptor<DescriptorPublicKey>> {
        &self.keychains
    }
@@ -308,43 +145,78 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    pub fn add_keychain(&mut self, keychain: K, descriptor: Descriptor<DescriptorPublicKey>) {
        let old_descriptor = &*self
            .keychains
-            .entry(keychain.clone())
+            .entry(keychain)
            .or_insert_with(|| descriptor.clone());
        assert_eq!(
            &descriptor, old_descriptor,
            "keychain already contains a different descriptor"
        );
-        self.replenish_lookahead(&keychain, self.lookahead);
    }

-    /// Get the lookahead setting.
+    /// Return the lookahead setting for each keychain.
    ///
-    /// Refer to [`new`] for more information on the `lookahead`.
+    /// Refer to [`set_lookahead`] for a deeper explanation of the `lookahead`.
    ///
-    /// [`new`]: Self::new
-    pub fn lookahead(&self) -> u32 {
-        self.lookahead
+    /// [`set_lookahead`]: Self::set_lookahead
+    pub fn lookaheads(&self) -> &BTreeMap<K, u32> {
+        &self.lookahead
    }

-    /// Store lookahead scripts until `target_index` (inclusive).
+    /// Convenience method to call [`set_lookahead`] for all keychains.
    ///
-    /// This does not change the global `lookahead` setting.
-    pub fn lookahead_to_target(&mut self, keychain: &K, target_index: u32) {
-        let (next_index, _) = self.next_index(keychain);
-
-        let temp_lookahead = (target_index + 1)
-            .checked_sub(next_index)
-            .filter(|&index| index > 0);
-
-        if let Some(temp_lookahead) = temp_lookahead {
-            self.replenish_lookahead(keychain, temp_lookahead);
+    /// [`set_lookahead`]: Self::set_lookahead
+    pub fn set_lookahead_for_all(&mut self, lookahead: u32) {
+        for keychain in &self.keychains.keys().cloned().collect::<Vec<_>>() {
+            self.set_lookahead(keychain, lookahead);
        }
    }

-    fn replenish_lookahead(&mut self, keychain: &K, lookahead: u32) {
+    /// Set the lookahead count for `keychain`.
+    ///
+    /// The lookahead is the number of scripts to cache ahead of the last revealed script index. This
+    /// is useful to find outputs you own when processing block data that lie beyond the last revealed
+    /// index. In certain situations, such as when performing an initial scan of the blockchain during
+    /// wallet import, it may be uncertain or unknown what the last revealed index is.
+    ///
+    /// # Panics
+    ///
+    /// This will panic if the `keychain` does not exist.
+    pub fn set_lookahead(&mut self, keychain: &K, lookahead: u32) {
+        self.lookahead.insert(keychain.clone(), lookahead);
+        self.replenish_lookahead(keychain);
+    }
+
+    /// Convenience method to call [`lookahead_to_target`] for multiple keychains.
+    ///
+    /// [`lookahead_to_target`]: Self::lookahead_to_target
+    pub fn lookahead_to_target_multi(&mut self, target_indexes: BTreeMap<K, u32>) {
+        for (keychain, target_index) in target_indexes {
+            self.lookahead_to_target(&keychain, target_index)
+        }
+    }
+
+    /// Store lookahead scripts until `target_index`.
+    ///
+    /// This does not change the `lookahead` setting.
+    pub fn lookahead_to_target(&mut self, keychain: &K, target_index: u32) {
+        let next_index = self.next_store_index(keychain);
+        if let Some(temp_lookahead) = target_index.checked_sub(next_index).filter(|&v| v > 0) {
+            let old_lookahead = self.lookahead.insert(keychain.clone(), temp_lookahead);
+            self.replenish_lookahead(keychain);
+
+            // revert
+            match old_lookahead {
+                Some(lookahead) => self.lookahead.insert(keychain.clone(), lookahead),
+                None => self.lookahead.remove(keychain),
+            };
+        }
+    }
+
+    fn replenish_lookahead(&mut self, keychain: &K) {
        let descriptor = self.keychains.get(keychain).expect("keychain must exist");
        let next_store_index = self.next_store_index(keychain);
        let next_reveal_index = self.last_revealed.get(keychain).map_or(0, |v| *v + 1);
+        let lookahead = self.lookahead.get(keychain).map_or(0, |v| *v);

        for (new_index, new_spk) in
            SpkIterator::new_with_range(descriptor, next_store_index..next_reveal_index + lookahead)
@@ -359,74 +231,64 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    fn next_store_index(&self, keychain: &K) -> u32 {
        self.inner()
            .all_spks()
-            // This range is filtering out the spks with a keychain different than
-            // `keychain`. We don't use filter here as range is more optimized.
            .range((keychain.clone(), u32::MIN)..(keychain.clone(), u32::MAX))
            .last()
-            .map_or(0, |((_, index), _)| *index + 1)
+            .map_or(0, |((_, v), _)| *v + 1)
    }

-    /// Get an unbounded spk iterator over a given `keychain`.
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the given `keychain`'s descriptor does not exist.
-    pub fn unbounded_spk_iter(&self, keychain: &K) -> SpkIterator<Descriptor<DescriptorPublicKey>> {
-        SpkIterator::new(
-            self.keychains
-                .get(keychain)
-                .expect("keychain does not exist")
-                .clone(),
-        )
-    }
-
-    /// Get unbounded spk iterators for all keychains.
-    pub fn all_unbounded_spk_iters(
+    /// Generates script pubkey iterators for every `keychain`. The iterators iterate over all
+    /// derivable script pubkeys.
+    pub fn spks_of_all_keychains(
        &self,
    ) -> BTreeMap<K, SpkIterator<Descriptor<DescriptorPublicKey>>> {
        self.keychains
            .iter()
-            .map(|(k, descriptor)| (k.clone(), SpkIterator::new(descriptor.clone())))
+            .map(|(keychain, descriptor)| {
+                (
+                    keychain.clone(),
+                    SpkIterator::new_with_range(descriptor.clone(), 0..),
+                )
+            })
            .collect()
    }

-    /// Iterate over revealed spks of all keychains.
-    pub fn revealed_spks(&self) -> impl DoubleEndedIterator<Item = (K, u32, &Script)> + Clone {
-        self.keychains.keys().flat_map(|keychain| {
-            self.revealed_keychain_spks(keychain)
-                .map(|(i, spk)| (keychain.clone(), i, spk))
-        })
+    /// Generates a script pubkey iterator for the given `keychain`'s descriptor (if it exists). The
+    /// iterator iterates over all derivable scripts of the keychain's descriptor.
+    ///
+    /// # Panics
+    ///
+    /// This will panic if the `keychain` does not exist.
+    pub fn spks_of_keychain(&self, keychain: &K) -> SpkIterator<Descriptor<DescriptorPublicKey>> {
+        let descriptor = self
+            .keychains
+            .get(keychain)
+            .expect("keychain must exist")
+            .clone();
+        SpkIterator::new_with_range(descriptor, 0..)
    }

-    /// Iterate over revealed spks of the given `keychain`.
-    pub fn revealed_keychain_spks(
+    /// Convenience method to get [`revealed_spks_of_keychain`] of all keychains.
+    ///
+    /// [`revealed_spks_of_keychain`]: Self::revealed_spks_of_keychain
+    pub fn revealed_spks_of_all_keychains(
+        &self,
+    ) -> BTreeMap<K, impl Iterator<Item = (u32, &Script)> + Clone> {
+        self.keychains
+            .keys()
+            .map(|keychain| (keychain.clone(), self.revealed_spks_of_keychain(keychain)))
+            .collect()
+    }
+
+    /// Iterates over the script pubkeys revealed by this index under `keychain`.
+    pub fn revealed_spks_of_keychain(
        &self,
        keychain: &K,
    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> + Clone {
-        let next_i = self.last_revealed.get(keychain).map_or(0, |&i| i + 1);
+        let next_index = self.last_revealed.get(keychain).map_or(0, |v| *v + 1);
        self.inner
            .all_spks()
-            .range((keychain.clone(), u32::MIN)..(keychain.clone(), next_i))
-            .map(|((_, i), spk)| (*i, spk.as_script()))
-    }
-
-    /// Iterate over revealed, but unused, spks of all keychains.
-    pub fn unused_spks(&self) -> impl DoubleEndedIterator<Item = (K, u32, &Script)> + Clone {
-        self.keychains.keys().flat_map(|keychain| {
-            self.unused_keychain_spks(keychain)
-                .map(|(i, spk)| (keychain.clone(), i, spk))
-        })
-    }
-
-    /// Iterate over revealed, but unused, spks of the given `keychain`.
-    pub fn unused_keychain_spks(
-        &self,
-        keychain: &K,
-    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> + Clone {
-        let next_i = self.last_revealed.get(keychain).map_or(0, |&i| i + 1);
-        self.inner
-            .unused_spks((keychain.clone(), u32::MIN)..(keychain.clone(), next_i))
-            .map(|((_, i), spk)| (*i, spk))
+            .range((keychain.clone(), u32::MIN)..(keychain.clone(), next_index))
+            .map(|((_, derivation_index), spk)| (*derivation_index, spk.as_script()))
    }

    /// Get the next derivation index for `keychain`. The next index is the index after the last revealed
@@ -525,45 +387,55 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
        let has_wildcard = descriptor.has_wildcard();

        let target_index = if has_wildcard { target_index } else { 0 };
-        let next_reveal_index = self
-            .last_revealed
-            .get(keychain)
-            .map_or(0, |index| *index + 1);
+        let next_reveal_index = self.last_revealed.get(keychain).map_or(0, |v| *v + 1);
+        let lookahead = self.lookahead.get(keychain).map_or(0, |v| *v);

-        debug_assert!(next_reveal_index + self.lookahead >= self.next_store_index(keychain));
+        debug_assert_eq!(
+            next_reveal_index + lookahead,
+            self.next_store_index(keychain)
+        );

-        // If the target_index is already revealed, we are done
-        if next_reveal_index > target_index {
-            return (
+        // if we need to reveal new indices, the latest revealed index goes here
+        let mut reveal_to_index = None;
+
+        // if the target is not yet revealed, but is already stored (due to lookahead), we need to
+        // set the `reveal_to_index` as target here (as the `for` loop below only updates
+        // `reveal_to_index` for indexes that are NOT stored)
+        if next_reveal_index <= target_index && target_index < next_reveal_index + lookahead {
+            reveal_to_index = Some(target_index);
+        }
+
+        // we range over indexes that are not stored
+        let range = next_reveal_index + lookahead..=target_index + lookahead;
+        for (new_index, new_spk) in SpkIterator::new_with_range(descriptor, range) {
+            let _inserted = self
+                .inner
+                .insert_spk((keychain.clone(), new_index), new_spk);
+            debug_assert!(_inserted, "must not have existing spk",);
+
+            // everything after `target_index` is stored for lookahead only
+            if new_index <= target_index {
+                reveal_to_index = Some(new_index);
+            }
+        }
+
+        match reveal_to_index {
+            Some(index) => {
+                let _old_index = self.last_revealed.insert(keychain.clone(), index);
+                debug_assert!(_old_index < Some(index));
+                (
+                    SpkIterator::new_with_range(descriptor.clone(), next_reveal_index..index + 1),
+                    super::ChangeSet(core::iter::once((keychain.clone(), index)).collect()),
+                )
+            }
+            None => (
                SpkIterator::new_with_range(
                    descriptor.clone(),
                    next_reveal_index..next_reveal_index,
                ),
                super::ChangeSet::default(),
-            );
+            ),
        }
-
-        // We range over the indexes that are not stored and insert their spks in the index.
-        // Indexes from next_reveal_index to next_reveal_index + lookahead are already stored (due
-        // to lookahead), so we only range from next_reveal_index + lookahead to target + lookahead
-        let range = next_reveal_index + self.lookahead..=target_index + self.lookahead;
-        for (new_index, new_spk) in SpkIterator::new_with_range(descriptor, range) {
-            let _inserted = self
-                .inner
-                .insert_spk((keychain.clone(), new_index), new_spk);
-            debug_assert!(_inserted, "must not have existing spk");
-            debug_assert!(
-                has_wildcard || new_index == 0,
-                "non-wildcard descriptors must not iterate past index 0"
-            );
-        }
-
-        let _old_index = self.last_revealed.insert(keychain.clone(), target_index);
-        debug_assert!(_old_index < Some(target_index));
-        (
-            SpkIterator::new_with_range(descriptor.clone(), next_reveal_index..target_index + 1),
-            super::ChangeSet(core::iter::once((keychain.clone(), target_index)).collect()),
-        )
    }

    /// Attempts to reveal the next script pubkey for `keychain`.
@@ -603,13 +475,13 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    ///
    /// Panics if `keychain` has never been added to the index
    pub fn next_unused_spk(&mut self, keychain: &K) -> ((u32, &Script), super::ChangeSet<K>) {
-        let need_new = self.unused_keychain_spks(keychain).next().is_none();
+        let need_new = self.unused_spks_of_keychain(keychain).next().is_none();
        // this rather strange branch is needed because of some lifetime issues
        if need_new {
            self.reveal_next_spk(keychain)
        } else {
            (
-                self.unused_keychain_spks(keychain)
+                self.unused_spks_of_keychain(keychain)
                    .next()
                    .expect("we already know next exists"),
                super::ChangeSet::default(),
@@ -617,44 +489,58 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
        }
    }

-    /// Iterate over all [`OutPoint`]s that point to `TxOut`s with script pubkeys derived from
-    /// `keychain`.
+    /// Marks the script pubkey at `index` as used even though the tracker hasn't seen an output with it.
+    /// This only has an effect when the `index` had been added to `self` already and was unused.
    ///
-    /// Use [`keychain_outpoints_in_range`](KeychainTxOutIndex::keychain_outpoints_in_range) to
-    /// iterate over a specific derivation range.
-    pub fn keychain_outpoints(
-        &self,
-        keychain: &K,
-    ) -> impl DoubleEndedIterator<Item = (u32, OutPoint)> + '_ {
-        self.keychain_outpoints_in_range(keychain, ..)
+    /// Returns whether the `index` was initially present as `unused`.
+    ///
+    /// This is useful when you want to reserve a script pubkey for something but don't want to add
+    /// the transaction output using it to the index yet. Other callers will consider `index` on
+    /// `keychain` used until you call [`unmark_used`].
+    ///
+    /// [`unmark_used`]: Self::unmark_used
+    pub fn mark_used(&mut self, keychain: &K, index: u32) -> bool {
+        self.inner.mark_used(&(keychain.clone(), index))
    }

-    /// Iterate over [`OutPoint`]s that point to `TxOut`s with script pubkeys derived from
-    /// `keychain` in a given derivation `range`.
-    pub fn keychain_outpoints_in_range(
+    /// Undoes the effect of [`mark_used`]. Returns whether the `index` is inserted back into
+    /// `unused`.
+    ///
+    /// Note that if `self` has scanned an output with this script pubkey, then this will have no
+    /// effect.
+    ///
+    /// [`mark_used`]: Self::mark_used
+    pub fn unmark_used(&mut self, keychain: &K, index: u32) -> bool {
+        self.inner.unmark_used(&(keychain.clone(), index))
+    }
+
+    /// Iterates over all unused script pubkeys for a `keychain` stored in the index.
+    pub fn unused_spks_of_keychain(
        &self,
        keychain: &K,
-        range: impl RangeBounds<u32>,
-    ) -> impl DoubleEndedIterator<Item = (u32, OutPoint)> + '_ {
-        let start = match range.start_bound() {
-            Bound::Included(i) => Bound::Included((keychain.clone(), *i)),
-            Bound::Excluded(i) => Bound::Excluded((keychain.clone(), *i)),
-            Bound::Unbounded => Bound::Unbounded,
-        };
-        let end = match range.end_bound() {
-            Bound::Included(i) => Bound::Included((keychain.clone(), *i)),
-            Bound::Excluded(i) => Bound::Excluded((keychain.clone(), *i)),
-            Bound::Unbounded => Bound::Unbounded,
-        };
+    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> {
+        let next_index = self.last_revealed.get(keychain).map_or(0, |&v| v + 1);
+        let range = (keychain.clone(), u32::MIN)..(keychain.clone(), next_index);
        self.inner
-            .outputs_in_range((start, end))
+            .unused_spks(range)
+            .map(|((_, i), script)| (*i, script))
+    }
+
+    /// Iterates over all the [`OutPoint`] that have a `TxOut` with a script pubkey derived from
+    /// `keychain`.
+    pub fn txouts_of_keychain(
+        &self,
+        keychain: &K,
+    ) -> impl DoubleEndedIterator<Item = (u32, OutPoint)> + '_ {
+        self.inner
+            .outputs_in_range((keychain.clone(), u32::MIN)..(keychain.clone(), u32::MAX))
            .map(|((_, i), op)| (*i, op))
    }

    /// Returns the highest derivation index of the `keychain` where [`KeychainTxOutIndex`] has
    /// found a [`TxOut`] with it's script pubkey.
    pub fn last_used_index(&self, keychain: &K) -> Option<u32> {
-        self.keychain_outpoints(keychain).last().map(|(i, _)| i)
+        self.txouts_of_keychain(keychain).last().map(|(i, _)| i)
    }

    /// Returns the highest derivation index of each keychain that [`KeychainTxOutIndex`] has found
--- a/crates/chain/src/lib.rs
+++ b/crates/chain/src/lib.rs
@@ -1,4 +1,4 @@
-//! This crate is a collection of core structures for [Bitcoin Dev Kit].
+//! This crate is a collection of core structures for [Bitcoin Dev Kit] (alpha release).
 //!
 //! The goal of this crate is to give wallets the mechanisms needed to:
 //!
@@ -12,8 +12,9 @@
 //!    you do it synchronously or asynchronously. If you know a fact about the blockchain, you can just
 //!    tell `bdk_chain`'s APIs about it, and that information will be integrated, if it can be done
 //!    consistently.
-//! 2. Data persistence agnostic -- `bdk_chain` does not care where you cache on-chain data, what you
-//!    cache or how you retrieve it from persistent storage.
+//! 2. Error-free APIs.
+//! 3. Data persistence agnostic -- `bdk_chain` does not care where you cache on-chain data, what you
+//!    cache or how you fetch it.
 //!
 //! [Bitcoin Dev Kit]: https://bitcoindevkit.org/

--- a/crates/chain/src/local_chain.rs
+++ b/crates/chain/src/local_chain.rs
@@ -1,15 +1,13 @@
 //! The [`LocalChain`] is a local implementation of [`ChainOracle`].

 use core::convert::Infallible;
-use core::ops::RangeBounds;

 use crate::collections::BTreeMap;
 use crate::{BlockId, ChainOracle};
 use alloc::sync::Arc;
-use bitcoin::block::Header;
 use bitcoin::BlockHash;

-/// The [`ChangeSet`] represents changes to [`LocalChain`].
+/// A structure that represents changes to [`LocalChain`].
 ///
 /// The key represents the block height, and the value either represents added a new [`CheckPoint`]
 /// (if [`Some`]), or removing a [`CheckPoint`] (if [`None`]).
@@ -35,42 +33,12 @@ struct CPInner {
    prev: Option<Arc<CPInner>>,
 }

-impl PartialEq for CheckPoint {
-    fn eq(&self, other: &Self) -> bool {
-        let self_cps = self.iter().map(|cp| cp.block_id());
-        let other_cps = other.iter().map(|cp| cp.block_id());
-        self_cps.eq(other_cps)
-    }
-}
-
 impl CheckPoint {
    /// Construct a new base block at the front of a linked list.
    pub fn new(block: BlockId) -> Self {
        Self(Arc::new(CPInner { block, prev: None }))
    }

-    /// Construct a checkpoint from a list of [`BlockId`]s in ascending height order.
-    ///
-    /// # Errors
-    ///
-    /// This method will error if any of the follow occurs:
-    ///
-    /// - The `blocks` iterator is empty, in which case, the error will be `None`.
-    /// - The `blocks` iterator is not in ascending height order.
-    /// - The `blocks` iterator contains multiple [`BlockId`]s of the same height.
-    ///
-    /// The error type is the last successful checkpoint constructed (if any).
-    pub fn from_block_ids(
-        block_ids: impl IntoIterator<Item = BlockId>,
-    ) -> Result<Self, Option<Self>> {
-        let mut blocks = block_ids.into_iter();
-        let mut acc = CheckPoint::new(blocks.next().ok_or(None)?);
-        for id in blocks {
-            acc = acc.push(id).map_err(Some)?;
-        }
-        Ok(acc)
-    }
-
    /// Construct a checkpoint from the given `header` and block `height`.
    ///
    /// If `header` is of the genesis block, the checkpoint won't have a [`prev`] node. Otherwise,
@@ -157,39 +125,9 @@ impl CheckPoint {
    pub fn iter(&self) -> CheckPointIter {
        self.clone().into_iter()
    }
-
-    /// Get checkpoint at `height`.
-    ///
-    /// Returns `None` if checkpoint at `height` does not exist`.
-    pub fn get(&self, height: u32) -> Option<Self> {
-        self.range(height..=height).next()
-    }
-
-    /// Iterate checkpoints over a height range.
-    ///
-    /// Note that we always iterate checkpoints in reverse height order (iteration starts at tip
-    /// height).
-    pub fn range<R>(&self, range: R) -> impl Iterator<Item = CheckPoint>
-    where
-        R: RangeBounds<u32>,
-    {
-        let start_bound = range.start_bound().cloned();
-        let end_bound = range.end_bound().cloned();
-        self.iter()
-            .skip_while(move |cp| match end_bound {
-                core::ops::Bound::Included(inc_bound) => cp.height() > inc_bound,
-                core::ops::Bound::Excluded(exc_bound) => cp.height() >= exc_bound,
-                core::ops::Bound::Unbounded => false,
-            })
-            .take_while(move |cp| match start_bound {
-                core::ops::Bound::Included(inc_bound) => cp.height() >= inc_bound,
-                core::ops::Bound::Excluded(exc_bound) => cp.height() > exc_bound,
-                core::ops::Bound::Unbounded => true,
-            })
-    }
 }

-/// Iterates over checkpoints backwards.
+/// A structure that iterates over checkpoints backwards.
 pub struct CheckPointIter {
    current: Option<Arc<CPInner>>,
 }
@@ -215,7 +153,7 @@ impl IntoIterator for CheckPoint {
    }
 }

-/// Used to update [`LocalChain`].
+/// A struct to update [`LocalChain`].
 ///
 /// This is used as input for [`LocalChain::apply_update`]. It contains the update's chain `tip` and
 /// a flag `introduce_older_blocks` which signals whether this update intends to introduce missing
@@ -227,7 +165,7 @@ impl IntoIterator for CheckPoint {
 /// Script-pubkey based syncing mechanisms may not introduce transactions in a chronological order
 /// so some updates require introducing older blocks (to anchor older transactions). For
 /// script-pubkey based syncing, `introduce_older_blocks` would typically be `true`.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct Update {
    /// The update chain's new tip.
    pub tip: CheckPoint,
@@ -241,9 +179,22 @@ pub struct Update {
 }

 /// This is a local implementation of [`ChainOracle`].
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct LocalChain {
    tip: CheckPoint,
+    index: BTreeMap<u32, BlockHash>,
+}
+
+impl PartialEq for LocalChain {
+    fn eq(&self, other: &Self) -> bool {
+        self.index == other.index
+    }
+}
+
+impl From<LocalChain> for BTreeMap<u32, BlockHash> {
+    fn from(value: LocalChain) -> Self {
+        value.index
+    }
 }

 impl ChainOracle for LocalChain {
@@ -254,16 +205,18 @@ impl ChainOracle for LocalChain {
        block: BlockId,
        chain_tip: BlockId,
    ) -> Result<Option<bool>, Self::Error> {
-        let chain_tip_cp = match self.tip.get(chain_tip.height) {
-            // we can only determine whether `block` is in chain of `chain_tip` if `chain_tip` can
-            // be identified in chain
-            Some(cp) if cp.hash() == chain_tip.hash => cp,
-            _ => return Ok(None),
-        };
-        match chain_tip_cp.get(block.height) {
-            Some(cp) => Ok(Some(cp.hash() == block.hash)),
-            None => Ok(None),
+        if block.height > chain_tip.height {
+            return Ok(None);
        }
+        Ok(
+            match (
+                self.index.get(&block.height),
+                self.index.get(&chain_tip.height),
+            ) {
+                (Some(cp), Some(tip_cp)) => Some(*cp == block.hash && *tip_cp == chain_tip.hash),
+                _ => None,
+            },
+        )
    }

    fn get_chain_tip(&self) -> Result<BlockId, Self::Error> {
@@ -274,7 +227,7 @@ impl ChainOracle for LocalChain {
 impl LocalChain {
    /// Get the genesis hash.
    pub fn genesis_hash(&self) -> BlockHash {
-        self.tip.get(0).expect("genesis must exist").hash()
+        self.index.get(&0).copied().expect("must have genesis hash")
    }

    /// Construct [`LocalChain`] from genesis `hash`.
@@ -283,6 +236,7 @@ impl LocalChain {
        let height = 0;
        let chain = Self {
            tip: CheckPoint::new(BlockId { height, hash }),
+            index: core::iter::once((height, hash)).collect(),
        };
        let changeset = chain.initial_changeset();
        (chain, changeset)
@@ -299,6 +253,7 @@ impl LocalChain {
        let (mut chain, _) = Self::from_genesis_hash(genesis_hash);
        chain.apply_changeset(&changeset)?;

+        debug_assert!(chain._check_index_is_consistent_with_tip());
        debug_assert!(chain._check_changeset_is_applied(&changeset));

        Ok(chain)
@@ -306,11 +261,18 @@ impl LocalChain {

    /// Construct a [`LocalChain`] from a given `checkpoint` tip.
    pub fn from_tip(tip: CheckPoint) -> Result<Self, MissingGenesisError> {
-        let genesis_cp = tip.iter().last().expect("must have at least one element");
-        if genesis_cp.height() != 0 {
+        let mut chain = Self {
+            tip,
+            index: BTreeMap::new(),
+        };
+        chain.reindex(0);
+
+        if chain.index.get(&0).copied().is_none() {
            return Err(MissingGenesisError);
        }
-        Ok(Self { tip })
+
+        debug_assert!(chain._check_index_is_consistent_with_tip());
+        Ok(chain)
    }

    /// Constructs a [`LocalChain`] from a [`BTreeMap`] of height to [`BlockHash`].
@@ -318,11 +280,12 @@ impl LocalChain {
    /// The [`BTreeMap`] enforces the height order. However, the caller must ensure the blocks are
    /// all of the same chain.
    pub fn from_blocks(blocks: BTreeMap<u32, BlockHash>) -> Result<Self, MissingGenesisError> {
-        if blocks.get(&0).is_none() {
+        if !blocks.contains_key(&0) {
            return Err(MissingGenesisError);
        }

        let mut tip: Option<CheckPoint> = None;
+
        for block in &blocks {
            match tip {
                Some(curr) => {
@@ -335,9 +298,13 @@ impl LocalChain {
            }
        }

-        Ok(Self {
+        let chain = Self {
+            index: blocks,
            tip: tip.expect("already checked to have genesis"),
-        })
+        };
+
+        debug_assert!(chain._check_index_is_consistent_with_tip());
+        Ok(chain)
    }

    /// Get the highest checkpoint.
@@ -380,95 +347,6 @@ impl LocalChain {
        Ok(changeset)
    }

-    /// Update the chain with a given [`Header`] at `height` which you claim is connected to a existing block in the chain.
-    ///
-    /// This is useful when you have a block header that you want to record as part of the chain but
-    /// don't necessarily know that the `prev_blockhash` is in the chain.
-    ///
-    /// This will usually insert two new [`BlockId`]s into the chain: the header's block and the
-    /// header's `prev_blockhash` block. `connected_to` must already be in the chain but is allowed
-    /// to be `prev_blockhash` (in which case only one new block id will be inserted).
-    /// To be successful, `connected_to` must be chosen carefully so that `LocalChain`'s [update
-    /// rules][`apply_update`] are satisfied.
-    ///
-    /// # Errors
-    ///
-    /// [`ApplyHeaderError::InconsistentBlocks`] occurs if the `connected_to` block and the
-    /// [`Header`] is inconsistent. For example, if the `connected_to` block is the same height as
-    /// `header` or `prev_blockhash`, but has a different block hash. Or if the `connected_to`
-    /// height is greater than the header's `height`.
-    ///
-    /// [`ApplyHeaderError::CannotConnect`] occurs if the internal call to [`apply_update`] fails.
-    ///
-    /// [`apply_update`]: Self::apply_update
-    pub fn apply_header_connected_to(
-        &mut self,
-        header: &Header,
-        height: u32,
-        connected_to: BlockId,
-    ) -> Result<ChangeSet, ApplyHeaderError> {
-        let this = BlockId {
-            height,
-            hash: header.block_hash(),
-        };
-        let prev = height.checked_sub(1).map(|prev_height| BlockId {
-            height: prev_height,
-            hash: header.prev_blockhash,
-        });
-        let conn = match connected_to {
-            // `connected_to` can be ignored if same as `this` or `prev` (duplicate)
-            conn if conn == this || Some(conn) == prev => None,
-            // this occurs if:
-            // - `connected_to` height is the same as `prev`, but different hash
-            // - `connected_to` height is the same as `this`, but different hash
-            // - `connected_to` height is greater than `this` (this is not allowed)
-            conn if conn.height >= height.saturating_sub(1) => {
-                return Err(ApplyHeaderError::InconsistentBlocks)
-            }
-            conn => Some(conn),
-        };
-
-        let update = Update {
-            tip: CheckPoint::from_block_ids([conn, prev, Some(this)].into_iter().flatten())
-                .expect("block ids must be in order"),
-            introduce_older_blocks: false,
-        };
-
-        self.apply_update(update)
-            .map_err(ApplyHeaderError::CannotConnect)
-    }
-
-    /// Update the chain with a given [`Header`] connecting it with the previous block.
-    ///
-    /// This is a convenience method to call [`apply_header_connected_to`] with the `connected_to`
-    /// parameter being `height-1:prev_blockhash`. If there is no previous block (i.e. genesis), we
-    /// use the current block as `connected_to`.
-    ///
-    /// [`apply_header_connected_to`]: LocalChain::apply_header_connected_to
-    pub fn apply_header(
-        &mut self,
-        header: &Header,
-        height: u32,
-    ) -> Result<ChangeSet, CannotConnectError> {
-        let connected_to = match height.checked_sub(1) {
-            Some(prev_height) => BlockId {
-                height: prev_height,
-                hash: header.prev_blockhash,
-            },
-            None => BlockId {
-                height,
-                hash: header.block_hash(),
-            },
-        };
-        self.apply_header_connected_to(header, height, connected_to)
-            .map_err(|err| match err {
-                ApplyHeaderError::InconsistentBlocks => {
-                    unreachable!("connected_to is derived from the block so is always consistent")
-                }
-                ApplyHeaderError::CannotConnect(err) => err,
-            })
-    }
-
    /// Apply the given `changeset`.
    pub fn apply_changeset(&mut self, changeset: &ChangeSet) -> Result<(), MissingGenesisError> {
        if let Some(start_height) = changeset.keys().next().cloned() {
@@ -504,7 +382,9 @@ impl LocalChain {
                None => LocalChain::from_blocks(extension)?.tip(),
            };
            self.tip = new_tip;
+            self.reindex(start_height);

+            debug_assert!(self._check_index_is_consistent_with_tip());
            debug_assert!(self._check_changeset_is_applied(changeset));
        }

@@ -517,16 +397,16 @@ impl LocalChain {
    ///
    /// Replacing the block hash of an existing checkpoint will result in an error.
    pub fn insert_block(&mut self, block_id: BlockId) -> Result<ChangeSet, AlterCheckPointError> {
-        if let Some(original_cp) = self.tip.get(block_id.height) {
-            let original_hash = original_cp.hash();
+        if let Some(&original_hash) = self.index.get(&block_id.height) {
            if original_hash != block_id.hash {
                return Err(AlterCheckPointError {
                    height: block_id.height,
                    original_hash,
                    update_hash: Some(block_id.hash),
                });
+            } else {
+                return Ok(ChangeSet::default());
            }
-            return Ok(ChangeSet::default());
        }

        let mut changeset = ChangeSet::default();
@@ -540,51 +420,21 @@ impl LocalChain {
        Ok(changeset)
    }

-    /// Removes blocks from (and inclusive of) the given `block_id`.
-    ///
-    /// This will remove blocks with a height equal or greater than `block_id`, but only if
-    /// `block_id` exists in the chain.
-    ///
-    /// # Errors
-    ///
-    /// This will fail with [`MissingGenesisError`] if the caller attempts to disconnect from the
-    /// genesis block.
-    pub fn disconnect_from(&mut self, block_id: BlockId) -> Result<ChangeSet, MissingGenesisError> {
-        let mut remove_from = Option::<CheckPoint>::None;
-        let mut changeset = ChangeSet::default();
-        for cp in self.tip().iter() {
-            let cp_id = cp.block_id();
-            if cp_id.height < block_id.height {
+    /// Reindex the heights in the chain from (and including) `from` height
+    fn reindex(&mut self, from: u32) {
+        let _ = self.index.split_off(&from);
+        for cp in self.iter_checkpoints() {
+            if cp.height() < from {
                break;
            }
-            changeset.insert(cp_id.height, None);
-            if cp_id == block_id {
-                remove_from = Some(cp);
-            }
+            self.index.insert(cp.height(), cp.hash());
        }
-        self.tip = match remove_from.map(|cp| cp.prev()) {
-            // The checkpoint below the earliest checkpoint to remove will be the new tip.
-            Some(Some(new_tip)) => new_tip,
-            // If there is no checkpoint below the earliest checkpoint to remove, it means the
-            // "earliest checkpoint to remove" is the genesis block. We disallow removing the
-            // genesis block.
-            Some(None) => return Err(MissingGenesisError),
-            // If there is nothing to remove, we return an empty changeset.
-            None => return Ok(ChangeSet::default()),
-        };
-        Ok(changeset)
    }

    /// Derives an initial [`ChangeSet`], meaning that it can be applied to an empty chain to
    /// recover the current chain.
    pub fn initial_changeset(&self) -> ChangeSet {
-        self.tip
-            .iter()
-            .map(|cp| {
-                let block_id = cp.block_id();
-                (block_id.height, Some(block_id.hash))
-            })
-            .collect()
+        self.index.iter().map(|(k, v)| (*k, Some(*v))).collect()
    }

    /// Iterate over checkpoints in descending height order.
@@ -594,49 +444,28 @@ impl LocalChain {
        }
    }

+    /// Get a reference to the internal index mapping the height to block hash.
+    pub fn blocks(&self) -> &BTreeMap<u32, BlockHash> {
+        &self.index
+    }
+
+    fn _check_index_is_consistent_with_tip(&self) -> bool {
+        let tip_history = self
+            .tip
+            .iter()
+            .map(|cp| (cp.height(), cp.hash()))
+            .collect::<BTreeMap<_, _>>();
+        self.index == tip_history
+    }
+
    fn _check_changeset_is_applied(&self, changeset: &ChangeSet) -> bool {
-        let mut curr_cp = self.tip.clone();
-        for (height, exp_hash) in changeset.iter().rev() {
-            match curr_cp.get(*height) {
-                Some(query_cp) => {
-                    if query_cp.height() != *height || Some(query_cp.hash()) != *exp_hash {
-                        return false;
-                    }
-                    curr_cp = query_cp;
-                }
-                None => {
-                    if exp_hash.is_some() {
-                        return false;
-                    }
-                }
+        for (height, exp_hash) in changeset {
+            if self.index.get(height) != exp_hash.as_ref() {
+                return false;
            }
        }
        true
    }
-
-    /// Get checkpoint at given `height` (if it exists).
-    ///
-    /// This is a shorthand for calling [`CheckPoint::get`] on the [`tip`].
-    ///
-    /// [`tip`]: LocalChain::tip
-    pub fn get(&self, height: u32) -> Option<CheckPoint> {
-        self.tip.get(height)
-    }
-
-    /// Iterate checkpoints over a height range.
-    ///
-    /// Note that we always iterate checkpoints in reverse height order (iteration starts at tip
-    /// height).
-    ///
-    /// This is a shorthand for calling [`CheckPoint::range`] on the [`tip`].
-    ///
-    /// [`tip`]: LocalChain::tip
-    pub fn range<R>(&self, range: R) -> impl Iterator<Item = CheckPoint>
-    where
-        R: RangeBounds<u32>,
-    {
-        self.tip.range(range)
-    }
 }

 /// An error which occurs when a [`LocalChain`] is constructed without a genesis checkpoint.
@@ -706,30 +535,6 @@ impl core::fmt::Display for CannotConnectError {
 #[cfg(feature = "std")]
 impl std::error::Error for CannotConnectError {}

-/// The error type for [`LocalChain::apply_header_connected_to`].
-#[derive(Debug, Clone, PartialEq)]
-pub enum ApplyHeaderError {
-    /// Occurs when `connected_to` block conflicts with either the current block or previous block.
-    InconsistentBlocks,
-    /// Occurs when the update cannot connect with the original chain.
-    CannotConnect(CannotConnectError),
-}
-
-impl core::fmt::Display for ApplyHeaderError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            ApplyHeaderError::InconsistentBlocks => write!(
-                f,
-                "the `connected_to` block conflicts with either the current or previous block"
-            ),
-            ApplyHeaderError::CannotConnect(err) => core::fmt::Display::fmt(err, f),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ApplyHeaderError {}
-
 fn merge_chains(
    original_tip: CheckPoint,
    update_tip: CheckPoint,
--- a/crates/chain/src/persist.rs
+++ b/crates/chain/src/persist.rs
@@ -55,18 +55,6 @@ where
            // if written successfully, take and return `self.stage`
            .map(|_| Some(core::mem::take(&mut self.stage)))
    }
-
-    /// Stages a new changeset and commits it (along with any other previously staged changes) to
-    /// the persistence backend
-    ///
-    /// Convenience method for calling [`stage`] and then [`commit`].
-    ///
-    /// [`stage`]: Self::stage
-    /// [`commit`]: Self::commit
-    pub fn stage_and_commit(&mut self, changeset: C) -> Result<Option<C>, B::WriteError> {
-        self.stage(changeset);
-        self.commit()
-    }
 }

 /// A persistence backend for [`Persist`].
--- a/crates/chain/src/spk_iter.rs
+++ b/crates/chain/src/spk_iter.rs
@@ -43,24 +43,18 @@ impl<D> SpkIterator<D>
 where
    D: Borrow<Descriptor<DescriptorPublicKey>>,
 {
-    /// Create a new script pubkey iterator from `descriptor`.
-    ///
-    /// This iterates from derivation index 0 and stops at index 0x7FFFFFFF (as specified in
-    /// BIP-32). Non-wildcard descriptors will only return one script pubkey at derivation index 0.
-    ///
-    /// Use [`new_with_range`](SpkIterator::new_with_range) to create an iterator with a specified
-    /// derivation index range.
+    /// Creates a new script pubkey iterator starting at 0 from a descriptor.
    pub fn new(descriptor: D) -> Self {
        SpkIterator::new_with_range(descriptor, 0..=BIP32_MAX_INDEX)
    }

-    /// Create a new script pubkey iterator from `descriptor` and a given `range`.
-    ///
-    /// Non-wildcard descriptors will only emit a single script pubkey (at derivation index 0).
-    /// Wildcard descriptors have an end-bound of 0x7FFFFFFF (inclusive).
-    ///
-    /// Refer to [`new`](SpkIterator::new) for more.
-    pub fn new_with_range<R>(descriptor: D, range: R) -> Self
+    // Creates a new script pubkey iterator from a descriptor with a given range.
+    // If the descriptor doesn't have a wildcard, we shorten whichever range you pass in
+    // to have length <= 1. This means that if you pass in 0..0 or 0..1 the range will
+    // remain the same, but if you pass in 0..10, we'll shorten it to 0..1
+    // Also note that if the descriptor doesn't have a wildcard, passing in a range starting
+    // from n > 0, will return an empty iterator.
+    pub(crate) fn new_with_range<R>(descriptor: D, range: R) -> Self
    where
        R: RangeBounds<u32>,
    {
@@ -79,6 +73,13 @@ where
        // Because `end` is exclusive, we want the maximum value to be BIP32_MAX_INDEX + 1.
        end = end.min(BIP32_MAX_INDEX + 1);

+        if !descriptor.borrow().has_wildcard() {
+            // The length of the range should be at most 1
+            if end != start {
+                end = start + 1;
+            }
+        }
+
        Self {
            next_index: start,
            end,
@@ -86,11 +87,6 @@ where
            secp: Secp256k1::verification_only(),
        }
    }
-
-    /// Get a reference to the internal descriptor.
-    pub fn descriptor(&self) -> &D {
-        &self.descriptor
-    }
 }

 impl<D> Iterator for SpkIterator<D>
@@ -152,7 +148,7 @@ mod test {
        Descriptor<DescriptorPublicKey>,
        Descriptor<DescriptorPublicKey>,
    ) {
-        let mut txout_index = KeychainTxOutIndex::<TestKeychain>::new(0);
+        let mut txout_index = KeychainTxOutIndex::<TestKeychain>::default();

        let secp = Secp256k1::signing_only();
        let (external_descriptor,_) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/0/*)").unwrap();
@@ -249,14 +245,6 @@ mod test {
            SpkIterator::new_with_range(&no_wildcard_descriptor, 1..=2).next(),
            None
        );
-        assert_eq!(
-            SpkIterator::new_with_range(&no_wildcard_descriptor, 10..11).next(),
-            None
-        );
-        assert_eq!(
-            SpkIterator::new_with_range(&no_wildcard_descriptor, 10..=10).next(),
-            None
-        );
    }

    // The following dummy traits were created to test if SpkIterator is working properly.
--- a/crates/chain/src/spk_txout_index.rs
+++ b/crates/chain/src/spk_txout_index.rs
@@ -4,7 +4,7 @@ use crate::{
    collections::{hash_map::Entry, BTreeMap, BTreeSet, HashMap},
    indexed_tx_graph::Indexer,
 };
-use bitcoin::{OutPoint, Script, ScriptBuf, Transaction, TxOut, Txid};
+use bitcoin::{self, OutPoint, Script, ScriptBuf, Transaction, TxOut, Txid};

 /// An index storing [`TxOut`]s that have a script pubkey that matches those in a list.
 ///
@@ -168,7 +168,9 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
    ///
    /// Returns `None` if the `TxOut` hasn't been scanned or if nothing matching was found there.
    pub fn txout(&self, outpoint: OutPoint) -> Option<(&I, &TxOut)> {
-        self.txouts.get(&outpoint).map(|v| (&v.0, &v.1))
+        self.txouts
+            .get(&outpoint)
+            .map(|(spk_i, txout)| (spk_i, txout))
    }

    /// Returns the script that has been inserted at the `index`.
@@ -215,7 +217,7 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
    /// let unused_change_spks =
    ///     txout_index.unused_spks((change_index, u32::MIN)..(change_index, u32::MAX));
    /// ```
-    pub fn unused_spks<R>(&self, range: R) -> impl DoubleEndedIterator<Item = (&I, &Script)> + Clone
+    pub fn unused_spks<R>(&self, range: R) -> impl DoubleEndedIterator<Item = (&I, &Script)>
    where
        R: RangeBounds<I>,
    {
@@ -281,12 +283,12 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {

        for txin in &tx.input {
            if let Some((_, txout)) = self.txout(txin.previous_output) {
-                sent += txout.value.to_sat();
+                sent += txout.value;
            }
        }
        for txout in &tx.output {
            if self.index_of_spk(&txout.script_pubkey).is_some() {
-                received += txout.value.to_sat();
+                received += txout.value;
            }
        }

--- a/crates/chain/src/tx_data_traits.rs
+++ b/crates/chain/src/tx_data_traits.rs
@@ -5,25 +5,21 @@ use alloc::vec::Vec;

 /// Trait that "anchors" blockchain data to a specific block of height and hash.
 ///
-/// If transaction A is anchored in block B, and block B is in the best chain, we can
+/// [`Anchor`] implementations must be [`Ord`] by the anchor block's [`BlockId`] first.
+///
+/// I.e. If transaction A is anchored in block B, then if block B is in the best chain, we can
 /// assume that transaction A is also confirmed in the best chain. This does not necessarily mean
 /// that transaction A is confirmed in block B. It could also mean transaction A is confirmed in a
 /// parent block of B.
 ///
-/// Every [`Anchor`] implementation must contain a [`BlockId`] parameter, and must implement
-/// [`Ord`]. When implementing [`Ord`], the anchors' [`BlockId`]s should take precedence
-/// over other elements inside the [`Anchor`]s for comparison purposes, i.e., you should first
-/// compare the anchors' [`BlockId`]s and then care about the rest.
-///
-/// The example shows different types of anchors:
 /// ```
 /// # use bdk_chain::local_chain::LocalChain;
 /// # use bdk_chain::tx_graph::TxGraph;
 /// # use bdk_chain::BlockId;
 /// # use bdk_chain::ConfirmationHeightAnchor;
-/// # use bdk_chain::ConfirmationTimeHeightAnchor;
 /// # use bdk_chain::example_utils::*;
 /// # use bitcoin::hashes::Hash;
+///
 /// // Initialize the local chain with two blocks.
 /// let chain = LocalChain::from_blocks(
 ///     [
@@ -51,7 +47,6 @@ use alloc::vec::Vec;
 /// );
 ///
 /// // Insert `tx` into a `TxGraph` that uses `ConfirmationHeightAnchor` as the anchor type.
-/// // This anchor records the anchor block and the confirmation height of the transaction.
 /// // When a transaction is anchored with `ConfirmationHeightAnchor`, the anchor block and
 /// // confirmation block can be different. However, the confirmation block cannot be higher than
 /// // the anchor block and both blocks must be in the same chain for the anchor to be valid.
@@ -67,25 +62,6 @@ use alloc::vec::Vec;
 ///         confirmation_height: 1,
 ///     },
 /// );
-///
-/// // Insert `tx` into a `TxGraph` that uses `ConfirmationTimeHeightAnchor` as the anchor type.
-/// // This anchor records the anchor block, the confirmation height and time of the transaction.
-/// // When a transaction is anchored with `ConfirmationTimeHeightAnchor`, the anchor block and
-/// // confirmation block can be different. However, the confirmation block cannot be higher than
-/// // the anchor block and both blocks must be in the same chain for the anchor to be valid.
-/// let mut graph_c = TxGraph::<ConfirmationTimeHeightAnchor>::default();
-/// let _ = graph_c.insert_tx(tx.clone());
-/// graph_c.insert_anchor(
-///     tx.txid(),
-///     ConfirmationTimeHeightAnchor {
-///         anchor_block: BlockId {
-///             height: 2,
-///             hash: Hash::hash("third".as_bytes()),
-///         },
-///         confirmation_height: 1,
-///         confirmation_time: 123,
-///     },
-/// );
 /// ```
 pub trait Anchor: core::fmt::Debug + Clone + Eq + PartialOrd + Ord + core::hash::Hash {
    /// Returns the [`BlockId`] that the associated blockchain data is "anchored" in.
@@ -123,10 +99,8 @@ pub trait Append {
 }

 impl<K: Ord, V> Append for BTreeMap<K, V> {
-    fn append(&mut self, other: Self) {
-        // We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
-        // Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
-        BTreeMap::extend(self, other)
+    fn append(&mut self, mut other: Self) {
+        BTreeMap::append(self, &mut other)
    }

    fn is_empty(&self) -> bool {
@@ -135,10 +109,8 @@ impl<K: Ord, V> Append for BTreeMap<K, V> {
 }

 impl<T: Ord> Append for BTreeSet<T> {
-    fn append(&mut self, other: Self) {
-        // We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
-        // Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
-        BTreeSet::extend(self, other)
+    fn append(&mut self, mut other: Self) {
+        BTreeSet::append(self, &mut other)
    }

    fn is_empty(&self) -> bool {
--- a/crates/chain/src/tx_graph.rs
+++ b/crates/chain/src/tx_graph.rs
@@ -1,75 +1,39 @@
 //! Module for structures that store and traverse transactions.
 //!
-//! [`TxGraph`] contains transactions and indexes them so you can easily traverse the graph of
-//! those transactions. `TxGraph` is *monotone* in that you can always insert a transaction -- it
-//! does not care whether that transaction is in the current best chain or whether it conflicts with
-//! any of the existing transactions or what order you insert the transactions. This means that you
-//! can always combine two [`TxGraph`]s together, without resulting in inconsistencies. Furthermore,
-//! there is currently no way to delete a transaction.
-//!
-//! Transactions can be either whole or partial (i.e., transactions for which we only know some
-//! outputs, which we usually call "floating outputs"; these are usually inserted using the
-//! [`insert_txout`] method.).
-//!
-//! The graph contains transactions in the form of [`TxNode`]s. Each node contains the txid, the
-//! transaction (whole or partial), the blocks that it is anchored to (see the [`Anchor`]
-//! documentation for more details), and the timestamp of the last time we saw the transaction as
-//! unconfirmed.
+//! [`TxGraph`] is a monotone structure that inserts transactions and indexes the spends. The
+//! [`ChangeSet`] structure reports changes of [`TxGraph`] but can also be applied to a
+//! [`TxGraph`] as well. Lastly, [`TxDescendants`] is an [`Iterator`] that traverses descendants of
+//! a given transaction.
 //!
 //! Conflicting transactions are allowed to coexist within a [`TxGraph`]. This is useful for
-//! identifying and traversing conflicts and descendants of a given transaction. Some [`TxGraph`]
-//! methods only consider transactions that are "canonical" (i.e., in the best chain or in mempool).
-//! We decide which transactions are canonical based on the transaction's anchors and the
-//! `last_seen` (as unconfirmed) timestamp; see the [`try_get_chain_position`] documentation for
-//! more details.
-//!
-//! The [`ChangeSet`] reports changes made to a [`TxGraph`]; it can be used to either save to
-//! persistent storage, or to be applied to another [`TxGraph`].
-//!
-//! Lastly, you can use [`TxAncestors`]/[`TxDescendants`] to traverse ancestors and descendants of
-//! a given transaction, respectively.
+//! identifying and traversing conflicts and descendants of a given transaction.
 //!
 //! # Applying changes
 //!
-//! Methods that change the state of [`TxGraph`] will return [`ChangeSet`]s.
-//! [`ChangeSet`]s can be applied back to a [`TxGraph`] or be used to inform persistent storage
+//! Methods that apply changes to [`TxGraph`] will return [`ChangeSet`].
+//! [`ChangeSet`] can be applied back to a [`TxGraph`] or be used to inform persistent storage
 //! of the changes to [`TxGraph`].
 //!
-//! # Generics
-//!
-//! Anchors are represented as generics within `TxGraph<A>`. To make use of all functionality of the
-//! `TxGraph`, anchors (`A`) should implement [`Anchor`].
-//!
-//! Anchors are made generic so that different types of data can be stored with how a transaction is
-//! *anchored* to a given block. An example of this is storing a merkle proof of the transaction to
-//! the confirmation block - this can be done with a custom [`Anchor`] type. The minimal [`Anchor`]
-//! type would just be a [`BlockId`] which just represents the height and hash of the block which
-//! the transaction is contained in. Note that a transaction can be contained in multiple
-//! conflicting blocks (by nature of the Bitcoin network).
-//!
 //! ```
 //! # use bdk_chain::BlockId;
 //! # use bdk_chain::tx_graph::TxGraph;
 //! # use bdk_chain::example_utils::*;
 //! # use bitcoin::Transaction;
 //! # let tx_a = tx_from_hex(RAW_TX_1);
-//! let mut tx_graph: TxGraph = TxGraph::default();
+//! let mut graph: TxGraph = TxGraph::default();
+//! let mut another_graph: TxGraph = TxGraph::default();
 //!
 //! // insert a transaction
-//! let changeset = tx_graph.insert_tx(tx_a);
+//! let changeset = graph.insert_tx(tx_a);
 //!
-//! // We can restore the state of the `tx_graph` by applying all
-//! // the changesets obtained by mutating the original (the order doesn't matter).
-//! let mut restored_tx_graph: TxGraph = TxGraph::default();
-//! restored_tx_graph.apply_changeset(changeset);
-//!
-//! assert_eq!(tx_graph, restored_tx_graph);
+//! // the resulting changeset can be applied to another tx graph
+//! another_graph.apply_changeset(changeset);
 //! ```
 //!
-//! A [`TxGraph`] can also be updated with another [`TxGraph`] which merges them together.
+//! A [`TxGraph`] can also be updated with another [`TxGraph`].
 //!
 //! ```
-//! # use bdk_chain::{Append, BlockId};
+//! # use bdk_chain::BlockId;
 //! # use bdk_chain::tx_graph::TxGraph;
 //! # use bdk_chain::example_utils::*;
 //! # use bitcoin::Transaction;
@@ -85,15 +49,12 @@
 //! let changeset = graph.apply_update(update);
 //! assert!(changeset.is_empty());
 //! ```
-//! [`try_get_chain_position`]: TxGraph::try_get_chain_position
-//! [`insert_txout`]: TxGraph::insert_txout

 use crate::{
    collections::*, keychain::Balance, local_chain::LocalChain, Anchor, Append, BlockId,
    ChainOracle, ChainPosition, FullTxOut,
 };
 use alloc::collections::vec_deque::VecDeque;
-use alloc::sync::Arc;
 use alloc::vec::Vec;
 use bitcoin::{OutPoint, Script, Transaction, TxOut, Txid};
 use core::fmt::{self, Formatter};
@@ -130,13 +91,13 @@ impl<A> Default for TxGraph<A> {
    }
 }

-/// A transaction node in the [`TxGraph`].
+/// An outward-facing view of a (transaction) node in the [`TxGraph`].
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct TxNode<'a, T, A> {
    /// Txid of the transaction.
    pub txid: Txid,
    /// A partial or full representation of the transaction.
-    pub tx: T,
+    pub tx: &'a T,
    /// The blocks that the transaction is "anchored" in.
    pub anchors: &'a BTreeSet<A>,
    /// The last-seen unix timestamp of the transaction as unconfirmed.
@@ -147,7 +108,7 @@ impl<'a, T, A> Deref for TxNode<'a, T, A> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
-        &self.tx
+        self.tx
    }
 }

@@ -157,7 +118,7 @@ impl<'a, T, A> Deref for TxNode<'a, T, A> {
 /// outputs).
 #[derive(Clone, Debug, PartialEq)]
 enum TxNodeInternal {
-    Whole(Arc<Transaction>),
+    Whole(Transaction),
    Partial(BTreeMap<u32, TxOut>),
 }

@@ -167,7 +128,7 @@ impl Default for TxNodeInternal {
    }
 }

-/// A transaction that is included in the chain, or is still in mempool.
+/// An outwards-facing view of a transaction that is part of the *best chain*'s history.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct CanonicalTx<'a, T, A> {
    /// How the transaction is observed as (confirmed or unconfirmed).
@@ -212,7 +173,6 @@ impl<A> TxGraph<A> {
    pub fn all_txouts(&self) -> impl Iterator<Item = (OutPoint, &TxOut)> {
        self.txs.iter().flat_map(|(txid, (tx, _, _))| match tx {
            TxNodeInternal::Whole(tx) => tx
-                .as_ref()
                .output
                .iter()
                .enumerate()
@@ -244,13 +204,13 @@ impl<A> TxGraph<A> {
    }

    /// Iterate over all full transactions in the graph.
-    pub fn full_txs(&self) -> impl Iterator<Item = TxNode<'_, Arc<Transaction>, A>> {
+    pub fn full_txs(&self) -> impl Iterator<Item = TxNode<'_, Transaction, A>> {
        self.txs
            .iter()
            .filter_map(|(&txid, (tx, anchors, last_seen))| match tx {
                TxNodeInternal::Whole(tx) => Some(TxNode {
                    txid,
-                    tx: tx.clone(),
+                    tx,
                    anchors,
                    last_seen_unconfirmed: *last_seen,
                }),
@@ -263,16 +223,16 @@ impl<A> TxGraph<A> {
    /// Refer to [`get_txout`] for getting a specific [`TxOut`].
    ///
    /// [`get_txout`]: Self::get_txout
-    pub fn get_tx(&self, txid: Txid) -> Option<Arc<Transaction>> {
+    pub fn get_tx(&self, txid: Txid) -> Option<&Transaction> {
        self.get_tx_node(txid).map(|n| n.tx)
    }

    /// Get a transaction node by txid. This only returns `Some` for full transactions.
-    pub fn get_tx_node(&self, txid: Txid) -> Option<TxNode<'_, Arc<Transaction>, A>> {
+    pub fn get_tx_node(&self, txid: Txid) -> Option<TxNode<'_, Transaction, A>> {
        match &self.txs.get(&txid)? {
            (TxNodeInternal::Whole(tx), anchors, last_seen) => Some(TxNode {
                txid,
-                tx: tx.clone(),
+                tx,
                anchors,
                last_seen_unconfirmed: *last_seen,
            }),
@@ -283,7 +243,7 @@ impl<A> TxGraph<A> {
    /// Obtains a single tx output (if any) at the specified outpoint.
    pub fn get_txout(&self, outpoint: OutPoint) -> Option<&TxOut> {
        match &self.txs.get(&outpoint.txid)?.0 {
-            TxNodeInternal::Whole(tx) => tx.as_ref().output.get(outpoint.vout as usize),
+            TxNodeInternal::Whole(tx) => tx.output.get(outpoint.vout as usize),
            TxNodeInternal::Partial(txouts) => txouts.get(&outpoint.vout),
        }
    }
@@ -294,7 +254,6 @@ impl<A> TxGraph<A> {
    pub fn tx_outputs(&self, txid: Txid) -> Option<BTreeMap<u32, &TxOut>> {
        Some(match &self.txs.get(&txid)?.0 {
            TxNodeInternal::Whole(tx) => tx
-                .as_ref()
                .output
                .iter()
                .enumerate()
@@ -319,7 +278,7 @@ impl<A> TxGraph<A> {
    ///
    /// [`insert_txout`]: Self::insert_txout
    pub fn calculate_fee(&self, tx: &Transaction) -> Result<u64, CalculateFeeError> {
-        if tx.is_coinbase() {
+        if tx.is_coin_base() {
            return Ok(0);
        }

@@ -331,7 +290,7 @@ impl<A> TxGraph<A> {
                    (sum, missing_outpoints)
                }
                Some(txout) => {
-                    sum += txout.value.to_sat() as i64;
+                    sum += txout.value as i64;
                    (sum, missing_outpoints)
                }
            },
@@ -343,7 +302,7 @@ impl<A> TxGraph<A> {
        let outputs_sum = tx
            .output
            .iter()
-            .map(|txout| txout.value.to_sat() as i64)
+            .map(|txout| txout.value as i64)
            .sum::<i64>();

        let fee = inputs_sum - outputs_sum;
@@ -356,7 +315,7 @@ impl<A> TxGraph<A> {

    /// The transactions spending from this output.
    ///
-    /// [`TxGraph`] allows conflicting transactions within the graph. Obviously the transactions in
+    /// `TxGraph` allows conflicting transactions within the graph. Obviously the transactions in
    /// the returned set will never be in the same active-chain.
    pub fn outspends(&self, outpoint: OutPoint) -> &HashSet<Txid> {
        self.spends.get(&outpoint).unwrap_or(&self.empty_outspends)
@@ -372,15 +331,16 @@ impl<A> TxGraph<A> {
        &self,
        txid: Txid,
    ) -> impl DoubleEndedIterator<Item = (u32, &HashSet<Txid>)> + '_ {
-        let start = OutPoint::new(txid, 0);
-        let end = OutPoint::new(txid, u32::MAX);
+        let start = OutPoint { txid, vout: 0 };
+        let end = OutPoint {
+            txid,
+            vout: u32::MAX,
+        };
        self.spends
            .range(start..=end)
            .map(|(outpoint, spends)| (outpoint.vout, spends))
    }
-}

-impl<A: Clone + Ord> TxGraph<A> {
    /// Creates an iterator that filters and maps ancestor transactions.
    ///
    /// The iterator starts with the ancestors of the supplied `tx` (ancestor transactions of `tx`
@@ -394,10 +354,13 @@ impl<A: Clone + Ord> TxGraph<A> {
    ///
    /// The supplied closure returns an `Option<T>`, allowing the caller to map each `Transaction`
    /// it visits and decide whether to visit ancestors.
-    pub fn walk_ancestors<'g, T, F, O>(&'g self, tx: T, walk_map: F) -> TxAncestors<'g, A, F>
+    pub fn walk_ancestors<'g, F, O>(
+        &'g self,
+        tx: &'g Transaction,
+        walk_map: F,
+    ) -> TxAncestors<'g, A, F>
    where
-        T: Into<Arc<Transaction>>,
-        F: FnMut(usize, Arc<Transaction>) -> Option<O> + 'g,
+        F: FnMut(usize, &'g Transaction) -> Option<O> + 'g,
    {
        TxAncestors::new_exclude_root(self, tx, walk_map)
    }
@@ -418,9 +381,7 @@ impl<A: Clone + Ord> TxGraph<A> {
    {
        TxDescendants::new_exclude_root(self, txid, walk_map)
    }
-}

-impl<A> TxGraph<A> {
    /// Creates an iterator that both filters and maps conflicting transactions (this includes
    /// descendants of directly-conflicting transactions, which are also considered conflicts).
    ///
@@ -433,7 +394,7 @@ impl<A> TxGraph<A> {
    where
        F: FnMut(usize, Txid) -> Option<O> + 'g,
    {
-        let txids = self.direct_conflicts(tx).map(|(_, txid)| txid);
+        let txids = self.direct_conflitcs(tx).map(|(_, txid)| txid);
        TxDescendants::from_multiple_include_root(self, txids, walk_map)
    }

@@ -444,7 +405,7 @@ impl<A> TxGraph<A> {
    /// Note that this only returns directly conflicting txids and won't include:
    /// - descendants of conflicting transactions (which are technically also conflicting)
    /// - transactions conflicting with the given transaction's ancestors
-    pub fn direct_conflicts<'g>(
+    pub fn direct_conflitcs<'g>(
        &'g self,
        tx: &'g Transaction,
    ) -> impl Iterator<Item = (usize, Txid)> + '_ {
@@ -469,19 +430,6 @@ impl<A> TxGraph<A> {
 }

 impl<A: Clone + Ord> TxGraph<A> {
-    /// Transform the [`TxGraph`] to have [`Anchor`]s of another type.
-    ///
-    /// This takes in a closure of signature `FnMut(A) -> A2` which is called for each [`Anchor`] to
-    /// transform it.
-    pub fn map_anchors<A2: Clone + Ord, F>(self, f: F) -> TxGraph<A2>
-    where
-        F: FnMut(A) -> A2,
-    {
-        let mut new_graph = TxGraph::<A2>::default();
-        new_graph.apply_changeset(self.initial_changeset().map_anchors(f));
-        new_graph
-    }
-
    /// Construct a new [`TxGraph`] from a list of transactions.
    pub fn new(txs: impl IntoIterator<Item = Transaction>) -> Self {
        let mut new = Self::default();
@@ -518,17 +466,16 @@ impl<A: Clone + Ord> TxGraph<A> {
    /// The [`ChangeSet`] returned will be empty if `tx` already exists.
    pub fn insert_tx(&mut self, tx: Transaction) -> ChangeSet<A> {
        let mut update = Self::default();
-        update.txs.insert(
-            tx.txid(),
-            (TxNodeInternal::Whole(tx.into()), BTreeSet::new(), 0),
-        );
+        update
+            .txs
+            .insert(tx.txid(), (TxNodeInternal::Whole(tx), BTreeSet::new(), 0));
        self.apply_update(update)
    }

    /// Batch insert unconfirmed transactions.
    ///
    /// Items of `txs` are tuples containing the transaction and a *last seen* timestamp. The
-    /// *last seen* communicates when the transaction is last seen in mempool which is used for
+    /// *last seen* communicates when the transaction is last seen in the mempool which is used for
    /// conflict-resolution (refer to [`TxGraph::insert_seen_at`] for details).
    pub fn batch_insert_unconfirmed(
        &mut self,
@@ -554,11 +501,7 @@ impl<A: Clone + Ord> TxGraph<A> {

    /// Inserts the given `seen_at` for `txid` into [`TxGraph`].
    ///
-    /// Note that [`TxGraph`] only keeps track of the latest `seen_at`. To batch
-    /// update all unconfirmed transactions with the latest `seen_at`, see
-    /// [`update_last_seen_unconfirmed`].
-    ///
-    /// [`update_last_seen_unconfirmed`]: Self::update_last_seen_unconfirmed
+    /// Note that [`TxGraph`] only keeps track of the latest `seen_at`.
    pub fn insert_seen_at(&mut self, txid: Txid, seen_at: u64) -> ChangeSet<A> {
        let mut update = Self::default();
        let (_, _, update_last_seen) = update.txs.entry(txid).or_default();
@@ -566,65 +509,6 @@ impl<A: Clone + Ord> TxGraph<A> {
        self.apply_update(update)
    }

-    /// Update the last seen time for all unconfirmed transactions.
-    ///
-    /// This method updates the last seen unconfirmed time for this [`TxGraph`] by inserting
-    /// the given `seen_at` for every transaction not yet anchored to a confirmed block,
-    /// and returns the [`ChangeSet`] after applying all updates to `self`.
-    ///
-    /// This is useful for keeping track of the latest time a transaction was seen
-    /// unconfirmed, which is important for evaluating transaction conflicts in the same
-    /// [`TxGraph`]. For details of how [`TxGraph`] resolves conflicts, see the docs for
-    /// [`try_get_chain_position`].
-    ///
-    /// A normal use of this method is to call it with the current system time. Although
-    /// block headers contain a timestamp, using the header time would be less effective
-    /// at tracking mempool transactions, because it can drift from actual clock time, plus
-    /// we may want to update a transaction's last seen time repeatedly between blocks.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use bdk_chain::example_utils::*;
-    /// # use std::time::UNIX_EPOCH;
-    /// # let tx = tx_from_hex(RAW_TX_1);
-    /// # let mut tx_graph = bdk_chain::TxGraph::<()>::new([tx]);
-    /// let now = std::time::SystemTime::now()
-    ///     .duration_since(UNIX_EPOCH)
-    ///     .expect("valid duration")
-    ///     .as_secs();
-    /// let changeset = tx_graph.update_last_seen_unconfirmed(now);
-    /// assert!(!changeset.last_seen.is_empty());
-    /// ```
-    ///
-    /// Note that [`TxGraph`] only keeps track of the latest `seen_at`, so the given time must
-    /// by strictly greater than what is currently stored for a transaction to have an effect.
-    /// To insert a last seen time for a single txid, see [`insert_seen_at`].
-    ///
-    /// [`insert_seen_at`]: Self::insert_seen_at
-    /// [`try_get_chain_position`]: Self::try_get_chain_position
-    pub fn update_last_seen_unconfirmed(&mut self, seen_at: u64) -> ChangeSet<A> {
-        let mut changeset = ChangeSet::default();
-        let unanchored_txs: Vec<Txid> = self
-            .txs
-            .iter()
-            .filter_map(
-                |(&txid, (_, anchors, _))| {
-                    if anchors.is_empty() {
-                        Some(txid)
-                    } else {
-                        None
-                    }
-                },
-            )
-            .collect();
-
-        for txid in unanchored_txs {
-            changeset.append(self.insert_seen_at(txid, seen_at));
-        }
-        changeset
-    }
-
    /// Extends this graph with another so that `self` becomes the union of the two sets of
    /// transactions.
    ///
@@ -643,8 +527,7 @@ impl<A: Clone + Ord> TxGraph<A> {

    /// Applies [`ChangeSet`] to [`TxGraph`].
    pub fn apply_changeset(&mut self, changeset: ChangeSet<A>) {
-        for wrapped_tx in changeset.txs {
-            let tx = wrapped_tx.as_ref();
+        for tx in changeset.txs {
            let txid = tx.txid();

            tx.input
@@ -659,26 +542,27 @@ impl<A: Clone + Ord> TxGraph<A> {

            match self.txs.get_mut(&txid) {
                Some((tx_node @ TxNodeInternal::Partial(_), _, _)) => {
-                    *tx_node = TxNodeInternal::Whole(wrapped_tx.clone());
+                    *tx_node = TxNodeInternal::Whole(tx);
                }
                Some((TxNodeInternal::Whole(tx), _, _)) => {
                    debug_assert_eq!(
-                        tx.as_ref().txid(),
+                        tx.txid(),
                        txid,
                        "tx should produce txid that is same as key"
                    );
                }
                None => {
-                    self.txs.insert(
-                        txid,
-                        (TxNodeInternal::Whole(wrapped_tx), BTreeSet::new(), 0),
-                    );
+                    self.txs
+                        .insert(txid, (TxNodeInternal::Whole(tx), BTreeSet::new(), 0));
                }
            }
        }

        for (outpoint, txout) in changeset.txouts {
-            let tx_entry = self.txs.entry(outpoint.txid).or_default();
+            let tx_entry = self
+                .txs
+                .entry(outpoint.txid)
+                .or_insert_with(Default::default);

            match tx_entry {
                (TxNodeInternal::Whole(_), _, _) => { /* do nothing since we already have full tx */
@@ -691,13 +575,13 @@ impl<A: Clone + Ord> TxGraph<A> {

        for (anchor, txid) in changeset.anchors {
            if self.anchors.insert((anchor.clone(), txid)) {
-                let (_, anchors, _) = self.txs.entry(txid).or_default();
+                let (_, anchors, _) = self.txs.entry(txid).or_insert_with(Default::default);
                anchors.insert(anchor);
            }
        }

        for (txid, new_last_seen) in changeset.last_seen {
-            let (_, _, last_seen) = self.txs.entry(txid).or_default();
+            let (_, _, last_seen) = self.txs.entry(txid).or_insert_with(Default::default);
            if new_last_seen > *last_seen {
                *last_seen = new_last_seen;
            }
@@ -709,7 +593,7 @@ impl<A: Clone + Ord> TxGraph<A> {
    /// The [`ChangeSet`] would be the set difference between `update` and `self` (transactions that
    /// exist in `update` but not in `self`).
    pub(crate) fn determine_changeset(&self, update: TxGraph<A>) -> ChangeSet<A> {
-        let mut changeset = ChangeSet::<A>::default();
+        let mut changeset = ChangeSet::default();

        for (&txid, (update_tx_node, _, update_last_seen)) in &update.txs {
            let prev_last_seen: u64 = match (self.txs.get(&txid), update_tx_node) {
@@ -788,13 +672,13 @@ impl<A: Anchor> TxGraph<A> {
                    };
                    let mut has_missing_height = false;
                    for anchor_block in tx_anchors.iter().map(Anchor::anchor_block) {
-                        match chain.get(anchor_block.height) {
+                        match chain.blocks().get(&anchor_block.height) {
                            None => {
                                has_missing_height = true;
                                continue;
                            }
-                            Some(chain_cp) => {
-                                if chain_cp.hash() == anchor_block.hash {
+                            Some(chain_hash) => {
+                                if chain_hash == &anchor_block.hash {
                                    return true;
                                }
                            }
@@ -812,7 +696,7 @@ impl<A: Anchor> TxGraph<A> {
            .filter_map(move |(a, _)| {
                let anchor_block = a.anchor_block();
                if Some(anchor_block.height) != last_height_emitted
-                    && chain.get(anchor_block.height).is_none()
+                    && !chain.blocks().contains_key(&anchor_block.height)
                {
                    last_height_emitted = Some(anchor_block.height);
                    Some(anchor_block.height)
@@ -824,20 +708,8 @@ impl<A: Anchor> TxGraph<A> {

    /// Get the position of the transaction in `chain` with tip `chain_tip`.
    ///
-    /// Chain data is fetched from `chain`, a [`ChainOracle`] implementation.
-    ///
-    /// This method returns `Ok(None)` if the transaction is not found in the chain, and no longer
-    /// belongs in the mempool. The following factors are used to approximate whether an
-    /// unconfirmed transaction exists in the mempool (not evicted):
-    ///
-    /// 1. Unconfirmed transactions that conflict with confirmed transactions are evicted.
-    /// 2. Unconfirmed transactions that spend from transactions that are evicted, are also
-    ///    evicted.
-    /// 3. Given two conflicting unconfirmed transactions, the transaction with the lower
-    ///    `last_seen_unconfirmed` parameter is evicted. A transaction's `last_seen_unconfirmed`
-    ///    parameter is the max of all it's descendants' `last_seen_unconfirmed` parameters. If the
-    ///    final `last_seen_unconfirmed`s are the same, the transaction with the lower `txid` (by
-    ///    lexicographical order) is evicted.
+    /// If the given transaction of `txid` does not exist in the chain of `chain_tip`, `None` is
+    /// returned.
    ///
    /// # Error
    ///
@@ -863,17 +735,17 @@ impl<A: Anchor> TxGraph<A> {
            }
        }

-        // The tx is not anchored to a block in the best chain, which means that it
+        // The tx is not anchored to a block which is in the best chain, which means that it
        // might be in mempool, or it might have been dropped already.
        // Let's check conflicts to find out!
        let tx = match tx_node {
            TxNodeInternal::Whole(tx) => {
                // A coinbase tx that is not anchored in the best chain cannot be unconfirmed and
                // should always be filtered out.
-                if tx.is_coinbase() {
+                if tx.is_coin_base() {
                    return Ok(None);
                }
-                tx.clone()
+                tx
            }
            TxNodeInternal::Partial(_) => {
                // Partial transactions (outputs only) cannot have conflicts.
@@ -890,8 +762,8 @@ impl<A: Anchor> TxGraph<A> {
        // First of all, we retrieve all our ancestors. Since we're using `new_include_root`, the
        // resulting array will also include `tx`
        let unconfirmed_ancestor_txs =
-            TxAncestors::new_include_root(self, tx.clone(), |_, ancestor_tx: Arc<Transaction>| {
-                let tx_node = self.get_tx_node(ancestor_tx.as_ref().txid())?;
+            TxAncestors::new_include_root(self, tx, |_, ancestor_tx: &Transaction| {
+                let tx_node = self.get_tx_node(ancestor_tx.txid())?;
                // We're filtering the ancestors to keep only the unconfirmed ones (= no anchors in
                // the best chain)
                for block in tx_node.anchors {
@@ -907,10 +779,8 @@ impl<A: Anchor> TxGraph<A> {

        // We determine our tx's last seen, which is the max between our last seen,
        // and our unconf descendants' last seen.
-        let unconfirmed_descendants_txs = TxDescendants::new_include_root(
-            self,
-            tx.as_ref().txid(),
-            |_, descendant_txid: Txid| {
+        let unconfirmed_descendants_txs =
+            TxDescendants::new_include_root(self, tx.txid(), |_, descendant_txid: Txid| {
                let tx_node = self.get_tx_node(descendant_txid)?;
                // We're filtering the ancestors to keep only the unconfirmed ones (= no anchors in
                // the best chain)
@@ -922,9 +792,8 @@ impl<A: Anchor> TxGraph<A> {
                    }
                }
                Some(Ok(tx_node))
-            },
-        )
-        .collect::<Result<Vec<_>, C::Error>>()?;
+            })
+            .collect::<Result<Vec<_>, C::Error>>()?;

        let tx_last_seen = unconfirmed_descendants_txs
            .iter()
@@ -935,8 +804,7 @@ impl<A: Anchor> TxGraph<A> {
        // Now we traverse our ancestors and consider all their conflicts
        for tx_node in unconfirmed_ancestor_txs {
            // We retrieve all the transactions conflicting with this specific ancestor
-            let conflicting_txs =
-                self.walk_conflicts(tx_node.tx.as_ref(), |_, txid| self.get_tx_node(txid));
+            let conflicting_txs = self.walk_conflicts(tx_node.tx, |_, txid| self.get_tx_node(txid));

            // If a conflicting tx is in the best chain, or has `last_seen` higher than this ancestor, then
            // this tx cannot exist in the best chain
@@ -950,7 +818,7 @@ impl<A: Anchor> TxGraph<A> {
                    return Ok(None);
                }
                if conflicting_tx.last_seen_unconfirmed == *last_seen
-                    && conflicting_tx.as_ref().txid() > tx.as_ref().txid()
+                    && conflicting_tx.txid() > tx.txid()
                {
                    // Conflicting tx has priority if txid of conflicting tx > txid of original tx
                    return Ok(None);
@@ -1043,7 +911,7 @@ impl<A: Anchor> TxGraph<A> {
        &'a self,
        chain: &'a C,
        chain_tip: BlockId,
-    ) -> impl Iterator<Item = Result<CanonicalTx<'a, Arc<Transaction>, A>, C::Error>> {
+    ) -> impl Iterator<Item = Result<CanonicalTx<'a, Transaction, A>, C::Error>> {
        self.full_txs().filter_map(move |tx| {
            self.try_get_chain_position(chain, chain_tip, tx.txid)
                .map(|v| {
@@ -1065,7 +933,7 @@ impl<A: Anchor> TxGraph<A> {
        &'a self,
        chain: &'a C,
        chain_tip: BlockId,
-    ) -> impl Iterator<Item = CanonicalTx<'a, Arc<Transaction>, A>> {
+    ) -> impl Iterator<Item = CanonicalTx<'a, Transaction, A>> {
        self.try_list_chain_txs(chain, chain_tip)
            .map(|r| r.expect("oracle is infallible"))
    }
@@ -1077,8 +945,7 @@ impl<A: Anchor> TxGraph<A> {
    /// (`OI`) for convenience. If `OI` is not necessary, the caller can use `()`, or
    /// [`Iterator::enumerate`] over a list of [`OutPoint`]s.
    ///
-    /// Floating outputs (i.e., outputs for which we don't have the full transaction in the graph)
-    /// are ignored.
+    /// Floating outputs are ignored.
    ///
    /// # Error
    ///
@@ -1104,7 +971,7 @@ impl<A: Anchor> TxGraph<A> {
                        None => return Ok(None),
                    };

-                    let txout = match tx_node.tx.as_ref().output.get(op.vout as usize) {
+                    let txout = match tx_node.tx.output.get(op.vout as usize) {
                        Some(txout) => txout.clone(),
                        None => return Ok(None),
                    };
@@ -1126,7 +993,7 @@ impl<A: Anchor> TxGraph<A> {
                            txout,
                            chain_position,
                            spent_by,
-                            is_on_coinbase: tx_node.tx.is_coinbase(),
+                            is_on_coinbase: tx_node.tx.is_coin_base(),
                        },
                    )))
                },
@@ -1229,16 +1096,16 @@ impl<A: Anchor> TxGraph<A> {
            match &txout.chain_position {
                ChainPosition::Confirmed(_) => {
                    if txout.is_confirmed_and_spendable(chain_tip.height) {
-                        confirmed += txout.txout.value.to_sat();
+                        confirmed += txout.txout.value;
                    } else if !txout.is_mature(chain_tip.height) {
-                        immature += txout.txout.value.to_sat();
+                        immature += txout.txout.value;
                    }
                }
                ChainPosition::Unconfirmed(_) => {
                    if trust_predicate(&spk_i, &txout.txout.script_pubkey) {
-                        trusted_pending += txout.txout.value.to_sat();
+                        trusted_pending += txout.txout.value;
                    } else {
-                        untrusted_pending += txout.txout.value.to_sat();
+                        untrusted_pending += txout.txout.value;
                    }
                }
            }
@@ -1269,9 +1136,9 @@ impl<A: Anchor> TxGraph<A> {
    }
 }

-/// The [`ChangeSet`] represents changes to a [`TxGraph`].
+/// A structure that represents changes to a [`TxGraph`].
 ///
-/// Since [`TxGraph`] is monotone, the "changeset" can only contain transactions to be added and
+/// Since [`TxGraph`] is monotone "changeset" can only contain transactions to be added and
 /// not removed.
 ///
 /// Refer to [module-level documentation] for more.
@@ -1292,7 +1159,7 @@ impl<A: Anchor> TxGraph<A> {
 #[must_use]
 pub struct ChangeSet<A = ()> {
    /// Added transactions.
-    pub txs: BTreeSet<Arc<Transaction>>,
+    pub txs: BTreeSet<Transaction>,
    /// Added txouts.
    pub txouts: BTreeMap<OutPoint, TxOut>,
    /// Added anchors.
@@ -1313,6 +1180,11 @@ impl<A> Default for ChangeSet<A> {
 }

 impl<A> ChangeSet<A> {
+    /// Returns true if the [`ChangeSet`] is empty (no transactions or txouts).
+    pub fn is_empty(&self) -> bool {
+        self.txs.is_empty() && self.txouts.is_empty()
+    }
+
    /// Iterates over all outpoints contained within [`ChangeSet`].
    pub fn txouts(&self) -> impl Iterator<Item = (OutPoint, &TxOut)> {
        self.txs
@@ -1362,17 +1234,15 @@ impl<A> ChangeSet<A> {
        A: Anchor,
    {
        self.anchor_heights()
-            .filter(move |&height| local_chain.get(height).is_none())
+            .filter(move |height| !local_chain.blocks().contains_key(height))
    }
 }

 impl<A: Ord> Append for ChangeSet<A> {
-    fn append(&mut self, other: Self) {
-        // We use `extend` instead of `BTreeMap::append` due to performance issues with `append`.
-        // Refer to https://github.com/rust-lang/rust/issues/34666#issuecomment-675658420
-        self.txs.extend(other.txs);
-        self.txouts.extend(other.txouts);
-        self.anchors.extend(other.anchors);
+    fn append(&mut self, mut other: Self) {
+        self.txs.append(&mut other.txs);
+        self.txouts.append(&mut other.txouts);
+        self.anchors.append(&mut other.anchors);

        // last_seen timestamps should only increase
        self.last_seen.extend(
@@ -1392,26 +1262,6 @@ impl<A: Ord> Append for ChangeSet<A> {
    }
 }

-impl<A: Ord> ChangeSet<A> {
-    /// Transform the [`ChangeSet`] to have [`Anchor`]s of another type.
-    ///
-    /// This takes in a closure of signature `FnMut(A) -> A2` which is called for each [`Anchor`] to
-    /// transform it.
-    pub fn map_anchors<A2: Ord, F>(self, mut f: F) -> ChangeSet<A2>
-    where
-        F: FnMut(A) -> A2,
-    {
-        ChangeSet {
-            txs: self.txs,
-            txouts: self.txouts,
-            anchors: BTreeSet::<(A2, Txid)>::from_iter(
-                self.anchors.into_iter().map(|(a, txid)| (f(a), txid)),
-            ),
-            last_seen: self.last_seen,
-        }
-    }
-}
-
 impl<A> AsRef<TxGraph<A>> for TxGraph<A> {
    fn as_ref(&self) -> &TxGraph<A> {
        self
@@ -1422,13 +1272,13 @@ impl<A> AsRef<TxGraph<A>> for TxGraph<A> {
 ///
 /// The iterator excludes partial transactions.
 ///
-/// Returned by the [`walk_ancestors`] method of [`TxGraph`].
+/// This `struct` is created by the [`walk_ancestors`] method of [`TxGraph`].
 ///
 /// [`walk_ancestors`]: TxGraph::walk_ancestors
 pub struct TxAncestors<'g, A, F> {
    graph: &'g TxGraph<A>,
    visited: HashSet<Txid>,
-    queue: VecDeque<(usize, Arc<Transaction>)>,
+    queue: VecDeque<(usize, &'g Transaction)>,
    filter_map: F,
 }

@@ -1436,13 +1286,13 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
    /// Creates a `TxAncestors` that includes the starting `Transaction` when iterating.
    pub(crate) fn new_include_root(
        graph: &'g TxGraph<A>,
-        tx: impl Into<Arc<Transaction>>,
+        tx: &'g Transaction,
        filter_map: F,
    ) -> Self {
        Self {
            graph,
            visited: Default::default(),
-            queue: [(0, tx.into())].into(),
+            queue: [(0, tx)].into(),
            filter_map,
        }
    }
@@ -1450,7 +1300,7 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
    /// Creates a `TxAncestors` that excludes the starting `Transaction` when iterating.
    pub(crate) fn new_exclude_root(
        graph: &'g TxGraph<A>,
-        tx: impl Into<Arc<Transaction>>,
+        tx: &'g Transaction,
        filter_map: F,
    ) -> Self {
        let mut ancestors = Self {
@@ -1459,7 +1309,7 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
            queue: Default::default(),
            filter_map,
        };
-        ancestors.populate_queue(1, tx.into());
+        ancestors.populate_queue(1, tx);
        ancestors
    }

@@ -1472,13 +1322,12 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
        filter_map: F,
    ) -> Self
    where
-        I: IntoIterator,
-        I::Item: Into<Arc<Transaction>>,
+        I: IntoIterator<Item = &'g Transaction>,
    {
        Self {
            graph,
            visited: Default::default(),
-            queue: txs.into_iter().map(|tx| (0, tx.into())).collect(),
+            queue: txs.into_iter().map(|tx| (0, tx)).collect(),
            filter_map,
        }
    }
@@ -1492,8 +1341,7 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
        filter_map: F,
    ) -> Self
    where
-        I: IntoIterator,
-        I::Item: Into<Arc<Transaction>>,
+        I: IntoIterator<Item = &'g Transaction>,
    {
        let mut ancestors = Self {
            graph,
@@ -1502,12 +1350,12 @@ impl<'g, A, F> TxAncestors<'g, A, F> {
            filter_map,
        };
        for tx in txs {
-            ancestors.populate_queue(1, tx.into());
+            ancestors.populate_queue(1, tx);
        }
        ancestors
    }

-    fn populate_queue(&mut self, depth: usize, tx: Arc<Transaction>) {
+    fn populate_queue(&mut self, depth: usize, tx: &'g Transaction) {
        let ancestors = tx
            .input
            .iter()
@@ -1521,7 +1369,7 @@ impl<'g, A, F> TxAncestors<'g, A, F> {

 impl<'g, A, F, O> Iterator for TxAncestors<'g, A, F>
 where
-    F: FnMut(usize, Arc<Transaction>) -> Option<O>,
+    F: FnMut(usize, &'g Transaction) -> Option<O>,
 {
    type Item = O;

@@ -1530,7 +1378,7 @@ where
            // we have exhausted all paths when queue is empty
            let (ancestor_depth, tx) = self.queue.pop_front()?;
            // ignore paths when user filters them out
-            let item = match (self.filter_map)(ancestor_depth, tx.clone()) {
+            let item = match (self.filter_map)(ancestor_depth, tx) {
                Some(item) => item,
                None => continue,
            };
@@ -1542,7 +1390,7 @@ where

 /// An iterator that traverses transaction descendants.
 ///
-/// Returned by the [`walk_descendants`] method of [`TxGraph`].
+/// This `struct` is created by the [`walk_descendants`] method of [`TxGraph`].
 ///
 /// [`walk_descendants`]: TxGraph::walk_descendants
 pub struct TxDescendants<'g, A, F> {
--- a/crates/chain/tests/common/mod.rs
+++ b/crates/chain/tests/common/mod.rs
@@ -1,5 +1,4 @@
 mod tx_template;
-#[allow(unused_imports)]
 pub use tx_template::*;

 #[allow(unused_macros)]
@@ -70,7 +69,7 @@ macro_rules! changeset {
 #[allow(unused)]
 pub fn new_tx(lt: u32) -> bitcoin::Transaction {
    bitcoin::Transaction {
-        version: bitcoin::transaction::Version::non_standard(0x00),
+        version: 0x00,
        lock_time: bitcoin::absolute::LockTime::from_consensus(lt),
        input: vec![],
        output: vec![],
--- a/crates/chain/tests/common/tx_template.rs
+++ b/crates/chain/tests/common/tx_template.rs
@@ -1,10 +1,10 @@
 use rand::distributions::{Alphanumeric, DistString};
 use std::collections::HashMap;

-use bdk_chain::{tx_graph::TxGraph, Anchor, SpkTxOutIndex};
+use bdk_chain::{tx_graph::TxGraph, BlockId, SpkTxOutIndex};
 use bitcoin::{
-    locktime::absolute::LockTime, secp256k1::Secp256k1, transaction, Amount, OutPoint, ScriptBuf,
-    Sequence, Transaction, TxIn, TxOut, Txid, Witness,
+    locktime::absolute::LockTime, secp256k1::Secp256k1, OutPoint, ScriptBuf, Sequence, Transaction,
+    TxIn, TxOut, Txid, Witness,
 };
 use miniscript::Descriptor;

@@ -49,11 +49,11 @@ impl TxOutTemplate {
 }

 #[allow(dead_code)]
-pub fn init_graph<'a, A: Anchor + Clone + 'a>(
-    tx_templates: impl IntoIterator<Item = &'a TxTemplate<'a, A>>,
-) -> (TxGraph<A>, SpkTxOutIndex<u32>, HashMap<&'a str, Txid>) {
+pub fn init_graph<'a>(
+    tx_templates: impl IntoIterator<Item = &'a TxTemplate<'a, BlockId>>,
+) -> (TxGraph<BlockId>, SpkTxOutIndex<u32>, HashMap<&'a str, Txid>) {
    let (descriptor, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), "tr(tprv8ZgxMBicQKsPd3krDUsBAmtnRsK3rb8u5yi1zhQgMhF1tR8MW7xfE4rnrbbsrbPR52e7rKapu6ztw1jXveJSCGHEriUGZV7mCe88duLp5pj/86'/1'/0'/0/*)").unwrap();
-    let mut graph = TxGraph::<A>::default();
+    let mut graph = TxGraph::<BlockId>::default();
    let mut spk_index = SpkTxOutIndex::default();
    (0..10).for_each(|index| {
        spk_index.insert_spk(
@@ -68,7 +68,7 @@ pub fn init_graph<'a, A: Anchor + Clone + 'a>(

    for (bogus_txin_vout, tx_tmp) in tx_templates.into_iter().enumerate() {
        let tx = Transaction {
-            version: transaction::Version::non_standard(0),
+            version: 0,
            lock_time: LockTime::ZERO,
            input: tx_tmp
                .inputs
@@ -111,11 +111,11 @@ pub fn init_graph<'a, A: Anchor + Clone + 'a>(
                .iter()
                .map(|output| match &output.spk_index {
                    None => TxOut {
-                        value: Amount::from_sat(output.value),
+                        value: output.value,
                        script_pubkey: ScriptBuf::new(),
                    },
                    Some(index) => TxOut {
-                        value: Amount::from_sat(output.value),
+                        value: output.value,
                        script_pubkey: spk_index.spk_at_index(index).unwrap().to_owned(),
                    },
                })
@@ -126,7 +126,7 @@ pub fn init_graph<'a, A: Anchor + Clone + 'a>(
        spk_index.scan(&tx);
        let _ = graph.insert_tx(tx.clone());
        for anchor in tx_tmp.anchors.iter() {
-            let _ = graph.insert_anchor(tx.txid(), anchor.clone());
+            let _ = graph.insert_anchor(tx.txid(), *anchor);
        }
        if let Some(seen_at) = tx_tmp.last_seen {
            let _ = graph.insert_seen_at(tx.txid(), seen_at);
--- a/crates/chain/tests/test_indexed_tx_graph.rs
+++ b/crates/chain/tests/test_indexed_tx_graph.rs
@@ -1,17 +1,15 @@
 #[macro_use]
 mod common;

-use std::{collections::BTreeSet, sync::Arc};
+use std::collections::BTreeSet;

 use bdk_chain::{
    indexed_tx_graph::{self, IndexedTxGraph},
    keychain::{self, Balance, KeychainTxOutIndex},
    local_chain::LocalChain,
-    tx_graph, ChainPosition, ConfirmationHeightAnchor,
-};
-use bitcoin::{
-    secp256k1::Secp256k1, Amount, OutPoint, Script, ScriptBuf, Transaction, TxIn, TxOut,
+    tx_graph, BlockId, ChainPosition, ConfirmationHeightAnchor,
 };
+use bitcoin::{secp256k1::Secp256k1, OutPoint, Script, ScriptBuf, Transaction, TxIn, TxOut};
 use miniscript::Descriptor;

 /// Ensure [`IndexedTxGraph::insert_relevant_txs`] can successfully index transactions NOT presented
@@ -29,19 +27,18 @@ fn insert_relevant_txs() {
    let spk_0 = descriptor.at_derivation_index(0).unwrap().script_pubkey();
    let spk_1 = descriptor.at_derivation_index(9).unwrap().script_pubkey();

-    let mut graph = IndexedTxGraph::<ConfirmationHeightAnchor, KeychainTxOutIndex<()>>::new(
-        KeychainTxOutIndex::new(10),
-    );
+    let mut graph = IndexedTxGraph::<ConfirmationHeightAnchor, KeychainTxOutIndex<()>>::default();
    graph.index.add_keychain((), descriptor);
+    graph.index.set_lookahead(&(), 10);

    let tx_a = Transaction {
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: spk_0,
            },
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: spk_1,
            },
        ],
@@ -68,7 +65,7 @@ fn insert_relevant_txs() {

    let changeset = indexed_tx_graph::ChangeSet {
        graph: tx_graph::ChangeSet {
-            txs: txs.iter().cloned().map(Arc::new).collect(),
+            txs: txs.clone().into(),
            ..Default::default()
        },
        indexer: keychain::ChangeSet([((), 9_u32)].into()),
@@ -82,6 +79,7 @@ fn insert_relevant_txs() {
    assert_eq!(graph.initial_changeset(), changeset,);
 }

+#[test]
 /// Ensure consistency IndexedTxGraph list_* and balance methods. These methods lists
 /// relevant txouts and utxos from the information fetched from a ChainOracle (here a LocalChain).
 ///
@@ -109,7 +107,7 @@ fn insert_relevant_txs() {
 ///
 /// Finally Add more blocks to local chain until tx1 coinbase maturity hits.
 /// Assert maturity at coinbase maturity inflection height. Block height 98 and 99.
-#[test]
+
 fn test_list_owned_txouts() {
    // Create Local chains
    let local_chain = LocalChain::from_blocks((0..150).map(|i| (i as u32, h!("random"))).collect())
@@ -120,12 +118,12 @@ fn test_list_owned_txouts() {
    let (desc_1, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), "tr(tprv8ZgxMBicQKsPd3krDUsBAmtnRsK3rb8u5yi1zhQgMhF1tR8MW7xfE4rnrbbsrbPR52e7rKapu6ztw1jXveJSCGHEriUGZV7mCe88duLp5pj/86'/1'/0'/0/*)").unwrap();
    let (desc_2, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), "tr(tprv8ZgxMBicQKsPd3krDUsBAmtnRsK3rb8u5yi1zhQgMhF1tR8MW7xfE4rnrbbsrbPR52e7rKapu6ztw1jXveJSCGHEriUGZV7mCe88duLp5pj/86'/1'/0'/1/*)").unwrap();

-    let mut graph = IndexedTxGraph::<ConfirmationHeightAnchor, KeychainTxOutIndex<String>>::new(
-        KeychainTxOutIndex::new(10),
-    );
+    let mut graph =
+        IndexedTxGraph::<ConfirmationHeightAnchor, KeychainTxOutIndex<String>>::default();

    graph.index.add_keychain("keychain_1".into(), desc_1);
    graph.index.add_keychain("keychain_2".into(), desc_2);
+    graph.index.set_lookahead_for_all(10);

    // Get trusted and untrusted addresses

@@ -156,7 +154,7 @@ fn test_list_owned_txouts() {
            ..Default::default()
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(70000),
+            value: 70000,
            script_pubkey: trusted_spks[0].to_owned(),
        }],
        ..common::new_tx(0)
@@ -165,7 +163,7 @@ fn test_list_owned_txouts() {
    // tx2 is an incoming transaction received at untrusted keychain at block 1.
    let tx2 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(30000),
+            value: 30000,
            script_pubkey: untrusted_spks[0].to_owned(),
        }],
        ..common::new_tx(0)
@@ -178,7 +176,7 @@ fn test_list_owned_txouts() {
            ..Default::default()
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(10000),
+            value: 10000,
            script_pubkey: trusted_spks[1].to_owned(),
        }],
        ..common::new_tx(0)
@@ -187,7 +185,7 @@ fn test_list_owned_txouts() {
    // tx4 is an external transaction receiving at untrusted keychain, unconfirmed.
    let tx4 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(20000),
+            value: 20000,
            script_pubkey: untrusted_spks[1].to_owned(),
        }],
        ..common::new_tx(0)
@@ -196,7 +194,7 @@ fn test_list_owned_txouts() {
    // tx5 is spending tx3 and receiving change at trusted keychain, unconfirmed.
    let tx5 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(15000),
+            value: 15000,
            script_pubkey: trusted_spks[2].to_owned(),
        }],
        ..common::new_tx(0)
@@ -214,8 +212,10 @@ fn test_list_owned_txouts() {
            (
                *tx,
                local_chain
-                    .get(height)
-                    .map(|cp| cp.block_id())
+                    .blocks()
+                    .get(&height)
+                    .cloned()
+                    .map(|hash| BlockId { height, hash })
                    .map(|anchor_block| ConfirmationHeightAnchor {
                        anchor_block,
                        confirmation_height: anchor_block.height,
@@ -230,8 +230,9 @@ fn test_list_owned_txouts() {
        |height: u32,
         graph: &IndexedTxGraph<ConfirmationHeightAnchor, KeychainTxOutIndex<String>>| {
            let chain_tip = local_chain
-                .get(height)
-                .map(|cp| cp.block_id())
+                .blocks()
+                .get(&height)
+                .map(|&hash| BlockId { height, hash })
                .unwrap_or_else(|| panic!("block must exist at {}", height));
            let txouts = graph
                .graph()
--- a/crates/chain/tests/test_keychain_txout_index.rs
+++ b/crates/chain/tests/test_keychain_txout_index.rs
@@ -9,7 +9,7 @@ use bdk_chain::{
    Append,
 };

-use bitcoin::{secp256k1::Secp256k1, Amount, OutPoint, ScriptBuf, Transaction, TxOut};
+use bitcoin::{secp256k1::Secp256k1, OutPoint, ScriptBuf, Transaction, TxOut};
 use miniscript::{Descriptor, DescriptorPublicKey};

 #[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]
@@ -18,14 +18,12 @@ enum TestKeychain {
    Internal,
 }

-fn init_txout_index(
-    lookahead: u32,
-) -> (
+fn init_txout_index() -> (
    bdk_chain::keychain::KeychainTxOutIndex<TestKeychain>,
    Descriptor<DescriptorPublicKey>,
    Descriptor<DescriptorPublicKey>,
 ) {
-    let mut txout_index = bdk_chain::keychain::KeychainTxOutIndex::<TestKeychain>::new(lookahead);
+    let mut txout_index = bdk_chain::keychain::KeychainTxOutIndex::<TestKeychain>::default();

    let secp = bdk_chain::bitcoin::secp256k1::Secp256k1::signing_only();
    let (external_descriptor,_) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "tr([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/0/*)").unwrap();
@@ -48,7 +46,7 @@ fn spk_at_index(descriptor: &Descriptor<DescriptorPublicKey>, index: u32) -> Scr
 fn test_set_all_derivation_indices() {
    use bdk_chain::indexed_tx_graph::Indexer;

-    let (mut txout_index, _, _) = init_txout_index(0);
+    let (mut txout_index, _, _) = init_txout_index();
    let derive_to: BTreeMap<_, _> =
        [(TestKeychain::External, 12), (TestKeychain::Internal, 24)].into();
    assert_eq!(
@@ -66,10 +64,19 @@ fn test_set_all_derivation_indices() {

 #[test]
 fn test_lookahead() {
-    let (mut txout_index, external_desc, internal_desc) = init_txout_index(10);
+    let (mut txout_index, external_desc, internal_desc) = init_txout_index();
+
+    // ensure it does not break anything if lookahead is set multiple times
+    (0..=10).for_each(|lookahead| txout_index.set_lookahead(&TestKeychain::External, lookahead));
+    (0..=20)
+        .filter(|v| v % 2 == 0)
+        .for_each(|lookahead| txout_index.set_lookahead(&TestKeychain::Internal, lookahead));
+
+    assert_eq!(txout_index.inner().all_spks().len(), 30);

    // given:
    // - external lookahead set to 10
+    // - internal lookahead set to 20
    // when:
    // - set external derivation index to value higher than last, but within the lookahead value
    // expect:
@@ -90,37 +97,37 @@ fn test_lookahead() {
        assert_eq!(
            txout_index.inner().all_spks().len(),
            10 /* external lookahead */ +
-            10 /* internal lookahead */ +
+            20 /* internal lookahead */ +
            index as usize + 1 /* `derived` count */
        );
        assert_eq!(
            txout_index
-                .revealed_keychain_spks(&TestKeychain::External)
+                .revealed_spks_of_keychain(&TestKeychain::External)
                .count(),
            index as usize + 1,
        );
        assert_eq!(
            txout_index
-                .revealed_keychain_spks(&TestKeychain::Internal)
+                .revealed_spks_of_keychain(&TestKeychain::Internal)
                .count(),
            0,
        );
        assert_eq!(
            txout_index
-                .unused_keychain_spks(&TestKeychain::External)
+                .unused_spks_of_keychain(&TestKeychain::External)
                .count(),
            index as usize + 1,
        );
        assert_eq!(
            txout_index
-                .unused_keychain_spks(&TestKeychain::Internal)
+                .unused_spks_of_keychain(&TestKeychain::Internal)
                .count(),
            0,
        );
    }

    // given:
-    // - internal lookahead is 10
+    // - internal lookahead is 20
    // - internal derivation index is `None`
    // when:
    // - derivation index is set ahead of current derivation index + lookahead
@@ -141,13 +148,13 @@ fn test_lookahead() {
    assert_eq!(
        txout_index.inner().all_spks().len(),
        10 /* external lookahead */ +
-        10 /* internal lookahead */ +
+        20 /* internal lookahead */ +
        20 /* external stored index count */ +
        25 /* internal stored index count */
    );
    assert_eq!(
        txout_index
-            .revealed_keychain_spks(&TestKeychain::Internal)
+            .revealed_spks_of_keychain(&TestKeychain::Internal)
            .count(),
        25,
    );
@@ -176,14 +183,14 @@ fn test_lookahead() {
                        .at_derivation_index(external_index)
                        .unwrap()
                        .script_pubkey(),
-                    value: Amount::from_sat(10_000),
+                    value: 10_000,
                },
                TxOut {
                    script_pubkey: internal_desc
                        .at_derivation_index(internal_index)
                        .unwrap()
                        .script_pubkey(),
-                    value: Amount::from_sat(10_000),
+                    value: 10_000,
                },
            ],
            ..common::new_tx(external_index)
@@ -199,13 +206,13 @@ fn test_lookahead() {
        );
        assert_eq!(
            txout_index
-                .revealed_keychain_spks(&TestKeychain::External)
+                .revealed_spks_of_keychain(&TestKeychain::External)
                .count(),
            last_external_index as usize + 1,
        );
        assert_eq!(
            txout_index
-                .revealed_keychain_spks(&TestKeychain::Internal)
+                .revealed_spks_of_keychain(&TestKeychain::Internal)
                .count(),
            last_internal_index as usize + 1,
        );
@@ -219,7 +226,8 @@ fn test_lookahead() {
 // - last used index should change as expected
 #[test]
 fn test_scan_with_lookahead() {
-    let (mut txout_index, external_desc, _) = init_txout_index(10);
+    let (mut txout_index, external_desc, _) = init_txout_index();
+    txout_index.set_lookahead_for_all(10);

    let spks: BTreeMap<u32, ScriptBuf> = [0, 10, 20, 30]
        .into_iter()
@@ -238,7 +246,7 @@ fn test_scan_with_lookahead() {
        let op = OutPoint::new(h!("fake tx"), spk_i);
        let txout = TxOut {
            script_pubkey: spk.clone(),
-            value: Amount::ZERO,
+            value: 0,
        };

        let changeset = txout_index.index_txout(op, &txout);
@@ -264,7 +272,7 @@ fn test_scan_with_lookahead() {
    let op = OutPoint::new(h!("fake tx"), 41);
    let txout = TxOut {
        script_pubkey: spk_41,
-        value: Amount::ZERO,
+        value: 0,
    };
    let changeset = txout_index.index_txout(op, &txout);
    assert!(changeset.is_empty());
@@ -273,7 +281,7 @@ fn test_scan_with_lookahead() {
 #[test]
 #[rustfmt::skip]
 fn test_wildcard_derivations() {
-    let (mut txout_index, external_desc, _) = init_txout_index(0);
+    let (mut txout_index, external_desc, _) = init_txout_index();
    let external_spk_0 = external_desc.at_derivation_index(0).unwrap().script_pubkey();
    let external_spk_16 = external_desc.at_derivation_index(16).unwrap().script_pubkey();
    let external_spk_26 = external_desc.at_derivation_index(26).unwrap().script_pubkey();
@@ -305,7 +313,7 @@ fn test_wildcard_derivations() {

    (0..=15)
        .chain([17, 20, 23])
-        .for_each(|index| assert!(txout_index.mark_used(TestKeychain::External, index)));
+        .for_each(|index| assert!(txout_index.mark_used(&TestKeychain::External, index)));

    assert_eq!(txout_index.next_index(&TestKeychain::External), (26, true));

@@ -321,7 +329,7 @@ fn test_wildcard_derivations() {
    // - Use all the derived till 26.
    // - next_unused() = ((27, <spk>), keychain::ChangeSet)
    (0..=26).for_each(|index| {
-        txout_index.mark_used(TestKeychain::External, index);
+        txout_index.mark_used(&TestKeychain::External, index);
    });

    let (spk, changeset) = txout_index.next_unused_spk(&TestKeychain::External);
@@ -331,7 +339,7 @@ fn test_wildcard_derivations() {

 #[test]
 fn test_non_wildcard_derivations() {
-    let mut txout_index = KeychainTxOutIndex::<TestKeychain>::new(0);
+    let mut txout_index = KeychainTxOutIndex::<TestKeychain>::default();

    let secp = bitcoin::secp256k1::Secp256k1::signing_only();
    let (no_wildcard_descriptor, _) = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, "wpkh([73c5da0a/86'/0'/0']xprv9xgqHN7yz9MwCkxsBPN5qetuNdQSUttZNKw1dcYTV4mkaAFiBVGQziHs3NRSWMkCzvgjEe3n9xV8oYywvM8at9yRqyaZVz6TYYhX98VjsUk/1/0)").unwrap();
@@ -364,7 +372,7 @@ fn test_non_wildcard_derivations() {
    // - derive new and next unused should return the old script
    // - store_up_to should not panic and return empty changeset
    assert_eq!(txout_index.next_index(&TestKeychain::External), (0, false));
-    txout_index.mark_used(TestKeychain::External, 0);
+    txout_index.mark_used(&TestKeychain::External, 0);

    let (spk, changeset) = txout_index.reveal_next_spk(&TestKeychain::External);
    assert_eq!(spk, (0, external_spk.as_script()));
@@ -381,108 +389,8 @@ fn test_non_wildcard_derivations() {
    // we check that spks_of_keychain returns a SpkIterator with just one element
    assert_eq!(
        txout_index
-            .revealed_keychain_spks(&TestKeychain::External)
+            .spks_of_keychain(&TestKeychain::External)
            .count(),
        1,
    );
 }
-
-/// Check that calling `lookahead_to_target` stores the expected spks.
-#[test]
-fn lookahead_to_target() {
-    #[derive(Default)]
-    struct TestCase {
-        /// Global lookahead value.
-        lookahead: u32,
-        /// Last revealed index for external keychain.
-        external_last_revealed: Option<u32>,
-        /// Last revealed index for internal keychain.
-        internal_last_revealed: Option<u32>,
-        /// Call `lookahead_to_target(External, u32)`.
-        external_target: Option<u32>,
-        /// Call `lookahead_to_target(Internal, u32)`.
-        internal_target: Option<u32>,
-    }
-
-    let test_cases = &[
-        TestCase {
-            lookahead: 0,
-            external_target: Some(100),
-            ..Default::default()
-        },
-        TestCase {
-            lookahead: 10,
-            internal_target: Some(99),
-            ..Default::default()
-        },
-        TestCase {
-            lookahead: 100,
-            internal_target: Some(9),
-            external_target: Some(10),
-            ..Default::default()
-        },
-        TestCase {
-            lookahead: 12,
-            external_last_revealed: Some(2),
-            internal_last_revealed: Some(2),
-            internal_target: Some(15),
-            external_target: Some(13),
-        },
-        TestCase {
-            lookahead: 13,
-            external_last_revealed: Some(100),
-            internal_last_revealed: Some(21),
-            internal_target: Some(120),
-            external_target: Some(130),
-        },
-    ];
-
-    for t in test_cases {
-        let (mut index, _, _) = init_txout_index(t.lookahead);
-
-        if let Some(last_revealed) = t.external_last_revealed {
-            let _ = index.reveal_to_target(&TestKeychain::External, last_revealed);
-        }
-        if let Some(last_revealed) = t.internal_last_revealed {
-            let _ = index.reveal_to_target(&TestKeychain::Internal, last_revealed);
-        }
-
-        let keychain_test_cases = [
-            (
-                TestKeychain::External,
-                t.external_last_revealed,
-                t.external_target,
-            ),
-            (
-                TestKeychain::Internal,
-                t.internal_last_revealed,
-                t.internal_target,
-            ),
-        ];
-        for (keychain, last_revealed, target) in keychain_test_cases {
-            if let Some(target) = target {
-                let original_last_stored_index = match last_revealed {
-                    Some(last_revealed) => Some(last_revealed + t.lookahead),
-                    None => t.lookahead.checked_sub(1),
-                };
-                let exp_last_stored_index = match original_last_stored_index {
-                    Some(original_last_stored_index) => {
-                        Ord::max(target, original_last_stored_index)
-                    }
-                    None => target,
-                };
-                index.lookahead_to_target(&keychain, target);
-                let keys = index
-                    .inner()
-                    .all_spks()
-                    .range((keychain.clone(), 0)..=(keychain.clone(), u32::MAX))
-                    .map(|(k, _)| k.clone())
-                    .collect::<Vec<_>>();
-                let exp_keys = core::iter::repeat(keychain)
-                    .zip(0_u32..=exp_last_stored_index)
-                    .collect::<Vec<_>>();
-                assert_eq!(keys, exp_keys);
-            }
-        }
-    }
-}
--- a/crates/chain/tests/test_local_chain.rs
+++ b/crates/chain/tests/test_local_chain.rs
@@ -1,14 +1,7 @@
-use std::ops::{Bound, RangeBounds};
-
-use bdk_chain::{
-    local_chain::{
-        AlterCheckPointError, ApplyHeaderError, CannotConnectError, ChangeSet, CheckPoint,
-        LocalChain, MissingGenesisError, Update,
-    },
-    BlockId,
+use bdk_chain::local_chain::{
+    AlterCheckPointError, CannotConnectError, ChangeSet, LocalChain, Update,
 };
-use bitcoin::{block::Header, hashes::Hash, BlockHash};
-use proptest::prelude::*;
+use bitcoin::BlockHash;

 #[macro_use]
 mod common;
@@ -295,27 +288,6 @@ fn update_local_chain() {
                ],
            },
        },
-        // Allow update that is shorter than original chain
-        //        | 0 | 1 | 2 | 3 | 4 | 5
-        // chain  | A       C   D   E   F
-        // update | A       C   D'
-        TestLocalChain {
-            name: "allow update that is shorter than original chain",
-            chain: local_chain![(0, h!("_")), (2, h!("C")), (3, h!("D")), (4, h!("E")), (5, h!("F"))],
-            update: chain_update![(0, h!("_")), (2, h!("C")), (3, h!("D'"))],
-            exp: ExpectedResult::Ok {
-                changeset: &[
-                    (3, Some(h!("D'"))),
-                    (4, None),
-                    (5, None),
-                ],
-                init_changeset: &[
-                    (0, Some(h!("_"))),
-                    (2, Some(h!("C"))),
-                    (3, Some(h!("D'"))),
-                ],
-            },
-        },
    ]
    .into_iter()
    .for_each(TestLocalChain::run);
@@ -378,398 +350,3 @@ fn local_chain_insert_block() {
        assert_eq!(chain, t.expected_final, "[{}] unexpected final chain", i,);
    }
 }
-
-#[test]
-fn local_chain_disconnect_from() {
-    struct TestCase {
-        name: &'static str,
-        original: LocalChain,
-        disconnect_from: (u32, BlockHash),
-        exp_result: Result<ChangeSet, MissingGenesisError>,
-        exp_final: LocalChain,
-    }
-
-    let test_cases = [
-        TestCase {
-            name: "try_replace_genesis_should_fail",
-            original: local_chain![(0, h!("_"))],
-            disconnect_from: (0, h!("_")),
-            exp_result: Err(MissingGenesisError),
-            exp_final: local_chain![(0, h!("_"))],
-        },
-        TestCase {
-            name: "try_replace_genesis_should_fail_2",
-            original: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C"))],
-            disconnect_from: (0, h!("_")),
-            exp_result: Err(MissingGenesisError),
-            exp_final: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C"))],
-        },
-        TestCase {
-            name: "from_does_not_exist",
-            original: local_chain![(0, h!("_")), (3, h!("C"))],
-            disconnect_from: (2, h!("B")),
-            exp_result: Ok(ChangeSet::default()),
-            exp_final: local_chain![(0, h!("_")), (3, h!("C"))],
-        },
-        TestCase {
-            name: "from_has_different_blockhash",
-            original: local_chain![(0, h!("_")), (2, h!("B"))],
-            disconnect_from: (2, h!("not_B")),
-            exp_result: Ok(ChangeSet::default()),
-            exp_final: local_chain![(0, h!("_")), (2, h!("B"))],
-        },
-        TestCase {
-            name: "disconnect_one",
-            original: local_chain![(0, h!("_")), (2, h!("B"))],
-            disconnect_from: (2, h!("B")),
-            exp_result: Ok(ChangeSet::from_iter([(2, None)])),
-            exp_final: local_chain![(0, h!("_"))],
-        },
-        TestCase {
-            name: "disconnect_three",
-            original: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C")), (4, h!("D"))],
-            disconnect_from: (2, h!("B")),
-            exp_result: Ok(ChangeSet::from_iter([(2, None), (3, None), (4, None)])),
-            exp_final: local_chain![(0, h!("_"))],
-        },
-    ];
-
-    for (i, t) in test_cases.into_iter().enumerate() {
-        println!("Case {}: {}", i, t.name);
-
-        let mut chain = t.original;
-        let result = chain.disconnect_from(t.disconnect_from.into());
-        assert_eq!(
-            result, t.exp_result,
-            "[{}:{}] unexpected changeset result",
-            i, t.name
-        );
-        assert_eq!(
-            chain, t.exp_final,
-            "[{}:{}] unexpected final chain",
-            i, t.name
-        );
-    }
-}
-
-#[test]
-fn checkpoint_from_block_ids() {
-    struct TestCase<'a> {
-        name: &'a str,
-        blocks: &'a [(u32, BlockHash)],
-        exp_result: Result<(), Option<(u32, BlockHash)>>,
-    }
-
-    let test_cases = [
-        TestCase {
-            name: "in_order",
-            blocks: &[(0, h!("A")), (1, h!("B")), (3, h!("D"))],
-            exp_result: Ok(()),
-        },
-        TestCase {
-            name: "with_duplicates",
-            blocks: &[(1, h!("B")), (2, h!("C")), (2, h!("C'"))],
-            exp_result: Err(Some((2, h!("C")))),
-        },
-        TestCase {
-            name: "not_in_order",
-            blocks: &[(1, h!("B")), (3, h!("D")), (2, h!("C"))],
-            exp_result: Err(Some((3, h!("D")))),
-        },
-        TestCase {
-            name: "empty",
-            blocks: &[],
-            exp_result: Err(None),
-        },
-        TestCase {
-            name: "single",
-            blocks: &[(21, h!("million"))],
-            exp_result: Ok(()),
-        },
-    ];
-
-    for (i, t) in test_cases.into_iter().enumerate() {
-        println!("running test case {}: '{}'", i, t.name);
-        let result = CheckPoint::from_block_ids(
-            t.blocks
-                .iter()
-                .map(|&(height, hash)| BlockId { height, hash }),
-        );
-        match t.exp_result {
-            Ok(_) => {
-                assert!(result.is_ok(), "[{}:{}] should be Ok", i, t.name);
-                let result_vec = {
-                    let mut v = result
-                        .unwrap()
-                        .into_iter()
-                        .map(|cp| (cp.height(), cp.hash()))
-                        .collect::<Vec<_>>();
-                    v.reverse();
-                    v
-                };
-                assert_eq!(
-                    &result_vec, t.blocks,
-                    "[{}:{}] not equal to original block ids",
-                    i, t.name
-                );
-            }
-            Err(exp_last) => {
-                assert!(result.is_err(), "[{}:{}] should be Err", i, t.name);
-                let err = result.unwrap_err();
-                assert_eq!(
-                    err.as_ref()
-                        .map(|last_cp| (last_cp.height(), last_cp.hash())),
-                    exp_last,
-                    "[{}:{}] error's last cp height should be {:?}, got {:?}",
-                    i,
-                    t.name,
-                    exp_last,
-                    err
-                );
-            }
-        }
-    }
-}
-
-#[test]
-fn checkpoint_query() {
-    struct TestCase {
-        chain: LocalChain,
-        /// The heights we want to call [`CheckPoint::query`] with, represented as an inclusive
-        /// range.
-        ///
-        /// If a [`CheckPoint`] exists at that height, we expect [`CheckPoint::query`] to return
-        /// it. If not, [`CheckPoint::query`] should return `None`.
-        query_range: (u32, u32),
-    }
-
-    let test_cases = [
-        TestCase {
-            chain: local_chain![(0, h!("_")), (1, h!("A"))],
-            query_range: (0, 2),
-        },
-        TestCase {
-            chain: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C"))],
-            query_range: (0, 3),
-        },
-    ];
-
-    for t in test_cases.into_iter() {
-        let tip = t.chain.tip();
-        for h in t.query_range.0..=t.query_range.1 {
-            let query_result = tip.get(h);
-
-            // perform an exhausitive search for the checkpoint at height `h`
-            let exp_hash = t
-                .chain
-                .iter_checkpoints()
-                .find(|cp| cp.height() == h)
-                .map(|cp| cp.hash());
-
-            match query_result {
-                Some(cp) => {
-                    assert_eq!(Some(cp.hash()), exp_hash);
-                    assert_eq!(cp.height(), h);
-                }
-                None => assert!(exp_hash.is_none()),
-            }
-        }
-    }
-}
-
-#[test]
-fn local_chain_apply_header_connected_to() {
-    fn header_from_prev_blockhash(prev_blockhash: BlockHash) -> Header {
-        Header {
-            version: bitcoin::block::Version::default(),
-            prev_blockhash,
-            merkle_root: bitcoin::hash_types::TxMerkleNode::all_zeros(),
-            time: 0,
-            bits: bitcoin::CompactTarget::default(),
-            nonce: 0,
-        }
-    }
-
-    struct TestCase {
-        name: &'static str,
-        chain: LocalChain,
-        header: Header,
-        height: u32,
-        connected_to: BlockId,
-        exp_result: Result<Vec<(u32, Option<BlockHash>)>, ApplyHeaderError>,
-    }
-
-    let test_cases = [
-        {
-            let header = header_from_prev_blockhash(h!("A"));
-            let hash = header.block_hash();
-            let height = 2;
-            let connected_to = BlockId { height, hash };
-            TestCase {
-                name: "connected_to_self_header_applied_to_self",
-                chain: local_chain![(0, h!("_")), (height, hash)],
-                header,
-                height,
-                connected_to,
-                exp_result: Ok(vec![]),
-            }
-        },
-        {
-            let prev_hash = h!("A");
-            let prev_height = 1;
-            let header = header_from_prev_blockhash(prev_hash);
-            let hash = header.block_hash();
-            let height = prev_height + 1;
-            let connected_to = BlockId {
-                height: prev_height,
-                hash: prev_hash,
-            };
-            TestCase {
-                name: "connected_to_prev_header_applied_to_self",
-                chain: local_chain![(0, h!("_")), (prev_height, prev_hash)],
-                header,
-                height,
-                connected_to,
-                exp_result: Ok(vec![(height, Some(hash))]),
-            }
-        },
-        {
-            let header = header_from_prev_blockhash(BlockHash::all_zeros());
-            let hash = header.block_hash();
-            let height = 0;
-            let connected_to = BlockId { height, hash };
-            TestCase {
-                name: "genesis_applied_to_self",
-                chain: local_chain![(0, hash)],
-                header,
-                height,
-                connected_to,
-                exp_result: Ok(vec![]),
-            }
-        },
-        {
-            let header = header_from_prev_blockhash(h!("Z"));
-            let height = 10;
-            let hash = header.block_hash();
-            let prev_height = height - 1;
-            let prev_hash = header.prev_blockhash;
-            TestCase {
-                name: "connect_at_connected_to",
-                chain: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C"))],
-                header,
-                height: 10,
-                connected_to: BlockId {
-                    height: 3,
-                    hash: h!("C"),
-                },
-                exp_result: Ok(vec![(prev_height, Some(prev_hash)), (height, Some(hash))]),
-            }
-        },
-        {
-            let prev_hash = h!("A");
-            let prev_height = 1;
-            let header = header_from_prev_blockhash(prev_hash);
-            let connected_to = BlockId {
-                height: prev_height,
-                hash: h!("not_prev_hash"),
-            };
-            TestCase {
-                name: "inconsistent_prev_hash",
-                chain: local_chain![(0, h!("_")), (prev_height, h!("not_prev_hash"))],
-                header,
-                height: prev_height + 1,
-                connected_to,
-                exp_result: Err(ApplyHeaderError::InconsistentBlocks),
-            }
-        },
-        {
-            let prev_hash = h!("A");
-            let prev_height = 1;
-            let header = header_from_prev_blockhash(prev_hash);
-            let height = prev_height + 1;
-            let connected_to = BlockId {
-                height,
-                hash: h!("not_current_hash"),
-            };
-            TestCase {
-                name: "inconsistent_current_block",
-                chain: local_chain![(0, h!("_")), (height, h!("not_current_hash"))],
-                header,
-                height,
-                connected_to,
-                exp_result: Err(ApplyHeaderError::InconsistentBlocks),
-            }
-        },
-        {
-            let header = header_from_prev_blockhash(h!("B"));
-            let height = 3;
-            let connected_to = BlockId {
-                height: 4,
-                hash: h!("D"),
-            };
-            TestCase {
-                name: "connected_to_is_greater",
-                chain: local_chain![(0, h!("_")), (2, h!("B"))],
-                header,
-                height,
-                connected_to,
-                exp_result: Err(ApplyHeaderError::InconsistentBlocks),
-            }
-        },
-    ];
-
-    for (i, t) in test_cases.into_iter().enumerate() {
-        println!("running test case {}: '{}'", i, t.name);
-        let mut chain = t.chain;
-        let result = chain.apply_header_connected_to(&t.header, t.height, t.connected_to);
-        let exp_result = t
-            .exp_result
-            .map(|cs| cs.iter().cloned().collect::<ChangeSet>());
-        assert_eq!(result, exp_result, "[{}:{}] unexpected result", i, t.name);
-    }
-}
-
-fn generate_height_range_bounds(
-    height_upper_bound: u32,
-) -> impl Strategy<Value = (Bound<u32>, Bound<u32>)> {
-    fn generate_height_bound(height_upper_bound: u32) -> impl Strategy<Value = Bound<u32>> {
-        prop_oneof![
-            (0..height_upper_bound).prop_map(Bound::Included),
-            (0..height_upper_bound).prop_map(Bound::Excluded),
-            Just(Bound::Unbounded),
-        ]
-    }
-    (
-        generate_height_bound(height_upper_bound),
-        generate_height_bound(height_upper_bound),
-    )
-}
-
-fn generate_checkpoints(max_height: u32, max_count: usize) -> impl Strategy<Value = CheckPoint> {
-    proptest::collection::btree_set(1..max_height, 0..max_count).prop_map(|mut heights| {
-        heights.insert(0); // must have genesis
-        CheckPoint::from_block_ids(heights.into_iter().map(|height| {
-            let hash = bitcoin::hashes::Hash::hash(height.to_le_bytes().as_slice());
-            BlockId { height, hash }
-        }))
-        .expect("blocks must be in order as it comes from btreeset")
-    })
-}
-
-proptest! {
-    #![proptest_config(ProptestConfig {
-        ..Default::default()
-    })]
-
-    /// Ensure that [`CheckPoint::range`] returns the expected checkpoint heights by comparing it
-    /// against a more primitive approach.
-    #[test]
-    fn checkpoint_range(
-        range in generate_height_range_bounds(21_000),
-        cp in generate_checkpoints(21_000, 2100)
-    ) {
-        let exp_heights = cp.iter().map(|cp| cp.height()).filter(|h| range.contains(h)).collect::<Vec<u32>>();
-        let heights = cp.range(range).map(|cp| cp.height()).collect::<Vec<u32>>();
-        prop_assert_eq!(heights, exp_heights);
-    }
-}
--- a/crates/chain/tests/test_spk_txout_index.rs
+++ b/crates/chain/tests/test_spk_txout_index.rs
@@ -1,5 +1,5 @@
 use bdk_chain::{indexed_tx_graph::Indexer, SpkTxOutIndex};
-use bitcoin::{absolute, transaction, Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut};
+use bitcoin::{absolute, OutPoint, ScriptBuf, Transaction, TxIn, TxOut};

 #[test]
 fn spk_txout_sent_and_received() {
@@ -11,11 +11,11 @@ fn spk_txout_sent_and_received() {
    index.insert_spk(1, spk2.clone());

    let tx1 = Transaction {
-        version: transaction::Version::TWO,
+        version: 0x02,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(42_000),
+            value: 42_000,
            script_pubkey: spk1.clone(),
        }],
    };
@@ -30,7 +30,7 @@ fn spk_txout_sent_and_received() {
    );

    let tx2 = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x1,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint {
@@ -41,12 +41,12 @@ fn spk_txout_sent_and_received() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: spk2,
            },
            TxOut {
                script_pubkey: spk1,
-                value: Amount::from_sat(30_000),
+                value: 30_000,
            },
        ],
    };
@@ -73,11 +73,11 @@ fn mark_used() {
    assert!(spk_index.is_used(&1));

    let tx1 = Transaction {
-        version: transaction::Version::TWO,
+        version: 0x02,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(42_000),
+            value: 42_000,
            script_pubkey: spk1,
        }],
    };
--- a/crates/chain/tests/test_tx_graph.rs
+++ b/crates/chain/tests/test_tx_graph.rs
@@ -8,13 +8,9 @@ use bdk_chain::{
    Anchor, Append, BlockId, ChainOracle, ChainPosition, ConfirmationHeightAnchor,
 };
 use bitcoin::{
-    absolute, hashes::Hash, transaction, Amount, BlockHash, OutPoint, ScriptBuf, Transaction, TxIn,
-    TxOut, Txid,
+    absolute, hashes::Hash, BlockHash, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid,
 };
-use common::*;
 use core::iter;
-use rand::RngCore;
-use std::sync::Arc;
 use std::vec;

 #[test]
@@ -24,14 +20,14 @@ fn insert_txouts() {
        (
            OutPoint::new(h!("tx1"), 1),
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
        ),
        (
            OutPoint::new(h!("tx1"), 2),
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: ScriptBuf::new(),
            },
        ),
@@ -41,21 +37,21 @@ fn insert_txouts() {
    let update_ops = [(
        OutPoint::new(h!("tx2"), 0),
        TxOut {
-            value: Amount::from_sat(20_000),
+            value: 20_000,
            script_pubkey: ScriptBuf::new(),
        },
    )];

    // One full transaction to be included in the update
    let update_txs = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint::null(),
            ..Default::default()
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(30_000),
+            value: 30_000,
            script_pubkey: ScriptBuf::new(),
        }],
    };
@@ -121,7 +117,7 @@ fn insert_txouts() {
        assert_eq!(
            graph.insert_tx(update_txs.clone()),
            ChangeSet {
-                txs: [Arc::new(update_txs.clone())].into(),
+                txs: [update_txs.clone()].into(),
                ..Default::default()
            }
        );
@@ -145,7 +141,7 @@ fn insert_txouts() {
    assert_eq!(
        changeset,
        ChangeSet {
-            txs: [Arc::new(update_txs.clone())].into(),
+            txs: [update_txs.clone()].into(),
            txouts: update_ops.clone().into(),
            anchors: [(conf_anchor, update_txs.txid()), (unconf_anchor, h!("tx2"))].into(),
            last_seen: [(h!("tx2"), 1000000)].into()
@@ -165,14 +161,14 @@ fn insert_txouts() {
            (
                1u32,
                &TxOut {
-                    value: Amount::from_sat(10_000),
+                    value: 10_000,
                    script_pubkey: ScriptBuf::new(),
                }
            ),
            (
                2u32,
                &TxOut {
-                    value: Amount::from_sat(20_000),
+                    value: 20_000,
                    script_pubkey: ScriptBuf::new(),
                }
            )
@@ -185,7 +181,7 @@ fn insert_txouts() {
        [(
            0u32,
            &TxOut {
-                value: Amount::from_sat(30_000),
+                value: 30_000,
                script_pubkey: ScriptBuf::new()
            }
        )]
@@ -196,7 +192,7 @@ fn insert_txouts() {
    assert_eq!(
        graph.initial_changeset(),
        ChangeSet {
-            txs: [Arc::new(update_txs.clone())].into(),
+            txs: [update_txs.clone()].into(),
            txouts: update_ops.into_iter().chain(original_ops).collect(),
            anchors: [(conf_anchor, update_txs.txid()), (unconf_anchor, h!("tx2"))].into(),
            last_seen: [(h!("tx2"), 1000000)].into()
@@ -207,7 +203,7 @@ fn insert_txouts() {
 #[test]
 fn insert_tx_graph_doesnt_count_coinbase_as_spent() {
    let tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint::null(),
@@ -217,8 +213,7 @@ fn insert_tx_graph_doesnt_count_coinbase_as_spent() {
    };

    let mut graph = TxGraph::<()>::default();
-    let changeset = graph.insert_tx(tx);
-    assert!(!changeset.is_empty());
+    let _ = graph.insert_tx(tx);
    assert!(graph.outspends(OutPoint::null()).is_empty());
    assert!(graph.tx_spends(Txid::all_zeros()).next().is_none());
 }
@@ -226,10 +221,10 @@ fn insert_tx_graph_doesnt_count_coinbase_as_spent() {
 #[test]
 fn insert_tx_graph_keeps_track_of_spend() {
    let tx1 = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
    };

    let op = OutPoint {
@@ -238,7 +233,7 @@ fn insert_tx_graph_keeps_track_of_spend() {
    };

    let tx2 = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: op,
@@ -267,57 +262,52 @@ fn insert_tx_graph_keeps_track_of_spend() {
 #[test]
 fn insert_tx_can_retrieve_full_tx_from_graph() {
    let tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint::null(),
            ..Default::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
    };

    let mut graph = TxGraph::<()>::default();
    let _ = graph.insert_tx(tx.clone());
-    assert_eq!(
-        graph.get_tx(tx.txid()).map(|tx| tx.as_ref().clone()),
-        Some(tx)
-    );
+    assert_eq!(graph.get_tx(tx.txid()), Some(&tx));
 }

 #[test]
 fn insert_tx_displaces_txouts() {
    let mut tx_graph = TxGraph::<()>::default();
    let tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(42_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 42_000,
+            script_pubkey: ScriptBuf::default(),
        }],
    };

-    let changeset = tx_graph.insert_txout(
-        OutPoint {
-            txid: tx.txid(),
-            vout: 0,
-        },
-        TxOut {
-            value: Amount::from_sat(1_337_000),
-            script_pubkey: ScriptBuf::default(),
-        },
-    );
-
-    assert!(!changeset.is_empty());
-
    let _ = tx_graph.insert_txout(
        OutPoint {
            txid: tx.txid(),
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(1_000_000_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 1_337_000,
+            script_pubkey: ScriptBuf::default(),
+        },
+    );
+
+    let _ = tx_graph.insert_txout(
+        OutPoint {
+            txid: tx.txid(),
+            vout: 0,
+        },
+        TxOut {
+            value: 1_000_000_000,
+            script_pubkey: ScriptBuf::default(),
        },
    );

@@ -331,7 +321,7 @@ fn insert_tx_displaces_txouts() {
            })
            .unwrap()
            .value,
-        Amount::from_sat(42_000)
+        42_000
    );
    assert_eq!(
        tx_graph.get_txout(OutPoint {
@@ -346,12 +336,12 @@ fn insert_tx_displaces_txouts() {
 fn insert_txout_does_not_displace_tx() {
    let mut tx_graph = TxGraph::<()>::default();
    let tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(42_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 42_000,
+            script_pubkey: ScriptBuf::default(),
        }],
    };

@@ -363,8 +353,8 @@ fn insert_txout_does_not_displace_tx() {
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(1_337_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 1_337_000,
+            script_pubkey: ScriptBuf::default(),
        },
    );

@@ -374,8 +364,8 @@ fn insert_txout_does_not_displace_tx() {
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(1_000_000_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 1_000_000_000,
+            script_pubkey: ScriptBuf::default(),
        },
    );

@@ -387,7 +377,7 @@ fn insert_txout_does_not_displace_tx() {
            })
            .unwrap()
            .value,
-        Amount::from_sat(42_000)
+        42_000
    );
    assert_eq!(
        tx_graph.get_txout(OutPoint {
@@ -402,21 +392,21 @@ fn insert_txout_does_not_displace_tx() {
 fn test_calculate_fee() {
    let mut graph = TxGraph::<()>::default();
    let intx1 = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(100),
-            script_pubkey: ScriptBuf::new(),
+            value: 100,
+            ..Default::default()
        }],
    };
    let intx2 = Transaction {
-        version: transaction::Version::TWO,
+        version: 0x02,
        lock_time: absolute::LockTime::ZERO,
        input: vec![],
        output: vec![TxOut {
-            value: Amount::from_sat(200),
-            script_pubkey: ScriptBuf::new(),
+            value: 200,
+            ..Default::default()
        }],
    };

@@ -426,8 +416,8 @@ fn test_calculate_fee() {
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(300),
-            script_pubkey: ScriptBuf::new(),
+            value: 300,
+            ..Default::default()
        },
    );

@@ -436,7 +426,7 @@ fn test_calculate_fee() {
    let _ = graph.insert_txout(intxout1.0, intxout1.1);

    let mut tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![
            TxIn {
@@ -459,8 +449,8 @@ fn test_calculate_fee() {
            },
        ],
        output: vec![TxOut {
-            value: Amount::from_sat(500),
-            script_pubkey: ScriptBuf::new(),
+            value: 500,
+            ..Default::default()
        }],
    };

@@ -492,13 +482,13 @@ fn test_calculate_fee() {
 #[test]
 fn test_calculate_fee_on_coinbase() {
    let tx = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x01,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint::null(),
            ..Default::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
    };

    let graph = TxGraph::<()>::default();
@@ -534,7 +524,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(h!("op0"), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL, TxOut::NULL],
+        output: vec![TxOut::default(), TxOut::default()],
        ..common::new_tx(0)
    };

@@ -544,7 +534,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_a0.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL, TxOut::NULL],
+        output: vec![TxOut::default(), TxOut::default()],
        ..common::new_tx(0)
    };

@@ -554,7 +544,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_a0.txid(), 1),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -563,7 +553,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(h!("op1"), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -573,7 +563,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_b0.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -583,7 +573,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_b0.txid(), 1),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -599,7 +589,7 @@ fn test_walk_ancestors() {
                ..TxIn::default()
            },
        ],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -608,7 +598,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(h!("op2"), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -618,7 +608,7 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_c1.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -634,7 +624,7 @@ fn test_walk_ancestors() {
                ..TxIn::default()
            },
        ],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -644,11 +634,11 @@ fn test_walk_ancestors() {
            previous_output: OutPoint::new(tx_d1.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

-    let mut graph = TxGraph::<BlockId>::new([
+    let mut graph = TxGraph::<BlockId>::new(vec![
        tx_a0.clone(),
        tx_b0.clone(),
        tx_b1.clone(),
@@ -663,23 +653,22 @@ fn test_walk_ancestors() {
    ]);

    [&tx_a0, &tx_b1].iter().for_each(|&tx| {
-        let changeset = graph.insert_anchor(tx.txid(), tip.block_id());
-        assert!(!changeset.is_empty());
+        let _ = graph.insert_anchor(tx.txid(), tip.block_id());
    });

    let ancestors = [
        graph
-            .walk_ancestors(tx_c0.clone(), |depth, tx| Some((depth, tx)))
+            .walk_ancestors(&tx_c0, |depth, tx| Some((depth, tx)))
            .collect::<Vec<_>>(),
        graph
-            .walk_ancestors(tx_d0.clone(), |depth, tx| Some((depth, tx)))
+            .walk_ancestors(&tx_d0, |depth, tx| Some((depth, tx)))
            .collect::<Vec<_>>(),
        graph
-            .walk_ancestors(tx_e0.clone(), |depth, tx| Some((depth, tx)))
+            .walk_ancestors(&tx_e0, |depth, tx| Some((depth, tx)))
            .collect::<Vec<_>>(),
        // Only traverse unconfirmed ancestors of tx_e0 this time
        graph
-            .walk_ancestors(tx_e0.clone(), |depth, tx| {
+            .walk_ancestors(&tx_e0, |depth, tx| {
                let tx_node = graph.get_tx_node(tx.txid())?;
                for block in tx_node.anchors {
                    match local_chain.is_block_in_chain(block.anchor_block(), tip.block_id()) {
@@ -706,14 +695,8 @@ fn test_walk_ancestors() {
        vec![(1, &tx_d1), (2, &tx_c2), (2, &tx_c3), (3, &tx_b2)],
    ];

-    for (txids, expected_txids) in ancestors.into_iter().zip(expected_ancestors) {
-        assert_eq!(
-            txids,
-            expected_txids
-                .into_iter()
-                .map(|(i, tx)| (i, Arc::new(tx.clone())))
-                .collect::<Vec<_>>()
-        );
+    for (txids, expected_txids) in ancestors.iter().zip(expected_ancestors.iter()) {
+        assert_eq!(txids, expected_txids);
    }
 }

@@ -727,7 +710,7 @@ fn test_conflicting_descendants() {
            previous_output,
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(0)
    };

@@ -737,7 +720,7 @@ fn test_conflicting_descendants() {
            previous_output,
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL, TxOut::NULL],
+        output: vec![TxOut::default(), TxOut::default()],
        ..common::new_tx(1)
    };

@@ -747,7 +730,7 @@ fn test_conflicting_descendants() {
            previous_output: OutPoint::new(tx_a.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(2)
    };

@@ -769,7 +752,7 @@ fn test_conflicting_descendants() {
 #[test]
 fn test_descendants_no_repeat() {
    let tx_a = Transaction {
-        output: vec![TxOut::NULL, TxOut::NULL, TxOut::NULL],
+        output: vec![TxOut::default(), TxOut::default(), TxOut::default()],
        ..common::new_tx(0)
    };

@@ -779,7 +762,7 @@ fn test_descendants_no_repeat() {
                previous_output: OutPoint::new(tx_a.txid(), vout),
                ..TxIn::default()
            }],
-            output: vec![TxOut::NULL],
+            output: vec![TxOut::default()],
            ..common::new_tx(1)
        })
        .collect::<Vec<_>>();
@@ -790,7 +773,7 @@ fn test_descendants_no_repeat() {
                previous_output: OutPoint::new(txs_b[vout as usize].txid(), vout),
                ..TxIn::default()
            }],
-            output: vec![TxOut::NULL],
+            output: vec![TxOut::default()],
            ..common::new_tx(2)
        })
        .collect::<Vec<_>>();
@@ -806,7 +789,7 @@ fn test_descendants_no_repeat() {
                ..TxIn::default()
            },
        ],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(3)
    };

@@ -815,7 +798,7 @@ fn test_descendants_no_repeat() {
            previous_output: OutPoint::new(tx_d.txid(), 0),
            ..TxIn::default()
        }],
-        output: vec![TxOut::NULL],
+        output: vec![TxOut::default()],
        ..common::new_tx(4)
    };

@@ -825,7 +808,7 @@ fn test_descendants_no_repeat() {
                previous_output: OutPoint::new(h!("tx_does_not_exist"), v),
                ..TxIn::default()
            }],
-            output: vec![TxOut::NULL],
+            output: vec![TxOut::default()],
            ..common::new_tx(v)
        })
        .collect::<Vec<_>>();
@@ -872,11 +855,11 @@ fn test_chain_spends() {
        input: vec![],
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -891,11 +874,11 @@ fn test_chain_spends() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(5_000),
+                value: 5_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(5_000),
+                value: 5_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -910,11 +893,11 @@ fn test_chain_spends() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -1044,12 +1027,10 @@ fn test_changeset_last_seen_append() {
            last_seen: original_ls.map(|ls| (txid, ls)).into_iter().collect(),
            ..Default::default()
        };
-        assert!(!original.is_empty() || original_ls.is_none());
        let update = ChangeSet::<()> {
            last_seen: update_ls.map(|ls| (txid, ls)).into_iter().collect(),
            ..Default::default()
        };
-        assert!(!update.is_empty() || update_ls.is_none());

        original.append(update);
        assert_eq!(
@@ -1059,34 +1040,6 @@ fn test_changeset_last_seen_append() {
    }
 }

-#[test]
-fn update_last_seen_unconfirmed() {
-    let mut graph = TxGraph::<()>::default();
-    let tx = new_tx(0);
-    let txid = tx.txid();
-
-    // insert a new tx
-    // initially we have a last_seen of 0, and no anchors
-    let _ = graph.insert_tx(tx);
-    let tx = graph.full_txs().next().unwrap();
-    assert_eq!(tx.last_seen_unconfirmed, 0);
-    assert!(tx.anchors.is_empty());
-
-    // higher timestamp should update last seen
-    let changeset = graph.update_last_seen_unconfirmed(2);
-    assert_eq!(changeset.last_seen.get(&txid).unwrap(), &2);
-
-    // lower timestamp has no effect
-    let changeset = graph.update_last_seen_unconfirmed(1);
-    assert!(changeset.last_seen.is_empty());
-
-    // once anchored, last seen is not updated
-    let _ = graph.insert_anchor(txid, ());
-    let changeset = graph.update_last_seen_unconfirmed(4);
-    assert!(changeset.is_empty());
-    assert_eq!(graph.full_txs().next().unwrap().last_seen_unconfirmed, 2);
-}
-
 #[test]
 fn test_missing_blocks() {
    /// An anchor implementation for testing, made up of `(the_anchor_block, random_data)`.
@@ -1219,86 +1172,3 @@ fn test_missing_blocks() {
        ),
    ]);
 }
-
-#[test]
-/// The `map_anchors` allow a caller to pass a function to reconstruct the [`TxGraph`] with any [`Anchor`],
-/// even though the function is non-deterministic.
-fn call_map_anchors_with_non_deterministic_anchor() {
-    #[derive(Debug, Default, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
-    /// A non-deterministic anchor
-    pub struct NonDeterministicAnchor {
-        pub anchor_block: BlockId,
-        pub non_deterministic_field: u32,
-    }
-
-    let template = [
-        TxTemplate {
-            tx_name: "tx1",
-            inputs: &[TxInTemplate::Bogus],
-            outputs: &[TxOutTemplate::new(10000, Some(1))],
-            anchors: &[block_id!(1, "A")],
-            last_seen: None,
-        },
-        TxTemplate {
-            tx_name: "tx2",
-            inputs: &[TxInTemplate::PrevTx("tx1", 0)],
-            outputs: &[TxOutTemplate::new(20000, Some(2))],
-            anchors: &[block_id!(2, "B")],
-            ..Default::default()
-        },
-        TxTemplate {
-            tx_name: "tx3",
-            inputs: &[TxInTemplate::PrevTx("tx2", 0)],
-            outputs: &[TxOutTemplate::new(30000, Some(3))],
-            anchors: &[block_id!(3, "C"), block_id!(4, "D")],
-            ..Default::default()
-        },
-    ];
-    let (graph, _, _) = init_graph(&template);
-    let new_graph = graph.clone().map_anchors(|a| NonDeterministicAnchor {
-        anchor_block: a,
-        // A non-deterministic value
-        non_deterministic_field: rand::thread_rng().next_u32(),
-    });
-
-    // Check all the details in new_graph reconstruct as well
-
-    let mut full_txs_vec: Vec<_> = graph.full_txs().collect();
-    full_txs_vec.sort();
-    let mut new_txs_vec: Vec<_> = new_graph.full_txs().collect();
-    new_txs_vec.sort();
-    let mut new_txs = new_txs_vec.iter();
-
-    for tx_node in full_txs_vec.iter() {
-        let new_txnode = new_txs.next().unwrap();
-        assert_eq!(new_txnode.txid, tx_node.txid);
-        assert_eq!(new_txnode.tx, tx_node.tx);
-        assert_eq!(
-            new_txnode.last_seen_unconfirmed,
-            tx_node.last_seen_unconfirmed
-        );
-        assert_eq!(new_txnode.anchors.len(), tx_node.anchors.len());
-
-        let mut new_anchors: Vec<_> = new_txnode.anchors.iter().map(|a| a.anchor_block).collect();
-        new_anchors.sort();
-        let mut old_anchors: Vec<_> = tx_node.anchors.iter().copied().collect();
-        old_anchors.sort();
-        assert_eq!(new_anchors, old_anchors);
-    }
-    assert!(new_txs.next().is_none());
-
-    let new_graph_anchors: Vec<_> = new_graph
-        .all_anchors()
-        .iter()
-        .map(|i| i.0.anchor_block)
-        .collect();
-    assert_eq!(
-        new_graph_anchors,
-        vec![
-            block_id!(1, "A"),
-            block_id!(2, "B"),
-            block_id!(3, "C"),
-            block_id!(4, "D"),
-        ]
-    );
-}
--- a/crates/chain/tests/test_tx_graph_conflicts.rs
+++ b/crates/chain/tests/test_tx_graph_conflicts.rs
@@ -110,7 +110,6 @@ fn test_tx_conflict_handling() {
                    ..Default::default()
                },
            ],
-            // the txgraph is going to pick tx_conflict_2 because of higher lexicographical txid
            exp_chain_txs: HashSet::from(["tx1", "tx_conflict_2"]),
            exp_chain_txouts: HashSet::from([("tx1", 0), ("tx_conflict_2", 0)]),
            exp_unspents: HashSet::from([("tx_conflict_2", 0)]),
--- a/crates/electrum/Cargo.toml
+++ b/crates/electrum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_electrum"
-version = "0.11.0"
+version = "0.4.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -12,11 +12,6 @@ readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bdk_chain = { path = "../chain", version = "0.12.0", default-features = false }
-electrum-client = { version = "0.19" }
+bdk_chain = { path = "../chain", version = "0.6.0", default-features = false }
+electrum-client = { version = "0.18" }
 #rustls = { version = "=0.21.1", optional = true, features = ["dangerous_configuration"] }
-
-[dev-dependencies]
-bdk_testenv = { path = "../testenv", default-features = false }
-electrsd = { version= "0.27.1", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
-anyhow = "1"
--- a/crates/electrum/README.md
+++ b/crates/electrum/README.md
@@ -1,7 +1,3 @@
 # BDK Electrum

-BDK Electrum extends [`electrum-client`] to update [`bdk_chain`] structures
-from an Electrum server.
-
-[`electrum-client`]: https://docs.rs/electrum-client/
-[`bdk_chain`]: https://docs.rs/bdk-chain/
+BDK Electrum client library for updating the keychain tracker.
--- a/crates/electrum/src/electrum_ext.rs
+++ b/crates/electrum/src/electrum_ext.rs
@@ -40,11 +40,15 @@ impl RelevantTxids {
    pub fn into_tx_graph(
        self,
        client: &Client,
+        seen_at: Option<u64>,
        missing: Vec<Txid>,
    ) -> Result<TxGraph<ConfirmationHeightAnchor>, Error> {
        let new_txs = client.batch_transaction_get(&missing)?;
        let mut graph = TxGraph::<ConfirmationHeightAnchor>::new(new_txs);
        for (txid, anchors) in self.0 {
+            if let Some(seen_at) = seen_at {
+                let _ = graph.insert_seen_at(txid, seen_at);
+            }
            for anchor in anchors {
                let _ = graph.insert_anchor(txid, anchor);
            }
@@ -52,20 +56,19 @@ impl RelevantTxids {
        Ok(graph)
    }

-    /// Finalizes the update by fetching `missing` txids from the `client`, where the
-    /// resulting [`TxGraph`] has anchors of type [`ConfirmationTimeHeightAnchor`].
-    ///
-    /// Refer to [`RelevantTxids`] for more details.
+    /// Finalizes [`RelevantTxids`] with `new_txs` and anchors of type
+    /// [`ConfirmationTimeHeightAnchor`].
    ///
    /// **Note:** The confirmation time might not be precisely correct if there has been a reorg.
-    // Electrum's API intends that we use the merkle proof API, we should change `bdk_electrum` to
-    // use it.
+    /// Electrum's API intends that we use the merkle proof API, we should change `bdk_electrum` to
+    /// use it.
    pub fn into_confirmation_time_tx_graph(
        self,
        client: &Client,
+        seen_at: Option<u64>,
        missing: Vec<Txid>,
    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
-        let graph = self.into_tx_graph(client, missing)?;
+        let graph = self.into_tx_graph(client, seen_at, missing)?;

        let relevant_heights = {
            let mut visited_heights = HashSet::new();
@@ -131,54 +134,64 @@ pub struct ElectrumUpdate {

 /// Trait to extend [`Client`] functionality.
 pub trait ElectrumExt {
-    /// Full scan the keychain scripts specified with the blockchain (via an Electrum client) and
-    /// returns updates for [`bdk_chain`] data structures.
+    /// Scan the blockchain (via electrum) for the data specified and returns updates for
+    /// [`bdk_chain`] data structures.
    ///
    /// - `prev_tip`: the most recent blockchain tip present locally
    /// - `keychain_spks`: keychains that we want to scan transactions for
+    /// - `txids`: transactions for which we want updated [`Anchor`]s
+    /// - `outpoints`: transactions associated with these outpoints (residing, spending) that we
+    ///     want to included in the update
    ///
-    /// The full scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
+    /// The scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
    /// transactions. `batch_size` specifies the max number of script pubkeys to request for in a
    /// single batch request.
-    fn full_scan<K: Ord + Clone>(
+    fn scan<K: Ord + Clone>(
        &self,
        prev_tip: CheckPoint,
        keychain_spks: BTreeMap<K, impl IntoIterator<Item = (u32, ScriptBuf)>>,
+        txids: impl IntoIterator<Item = Txid>,
+        outpoints: impl IntoIterator<Item = OutPoint>,
        stop_gap: usize,
        batch_size: usize,
    ) -> Result<(ElectrumUpdate, BTreeMap<K, u32>), Error>;

-    /// Sync a set of scripts with the blockchain (via an Electrum client) for the data specified
-    /// and returns updates for [`bdk_chain`] data structures.
+    /// Convenience method to call [`scan`] without requiring a keychain.
    ///
-    /// - `prev_tip`: the most recent blockchain tip present locally
-    /// - `misc_spks`: an iterator of scripts we want to sync transactions for
-    /// - `txids`: transactions for which we want updated [`Anchor`]s
-    /// - `outpoints`: transactions associated with these outpoints (residing, spending) that we
-    ///     want to include in the update
-    ///
-    /// `batch_size` specifies the max number of script pubkeys to request for in a single batch
-    /// request.
-    ///
-    /// If the scripts to sync are unknown, such as when restoring or importing a keychain that
-    /// may include scripts that have been used, use [`full_scan`] with the keychain.
-    ///
-    /// [`full_scan`]: ElectrumExt::full_scan
-    fn sync(
+    /// [`scan`]: ElectrumExt::scan
+    fn scan_without_keychain(
        &self,
        prev_tip: CheckPoint,
        misc_spks: impl IntoIterator<Item = ScriptBuf>,
        txids: impl IntoIterator<Item = Txid>,
        outpoints: impl IntoIterator<Item = OutPoint>,
        batch_size: usize,
-    ) -> Result<ElectrumUpdate, Error>;
+    ) -> Result<ElectrumUpdate, Error> {
+        let spk_iter = misc_spks
+            .into_iter()
+            .enumerate()
+            .map(|(i, spk)| (i as u32, spk));
+
+        let (electrum_update, _) = self.scan(
+            prev_tip,
+            [((), spk_iter)].into(),
+            txids,
+            outpoints,
+            usize::MAX,
+            batch_size,
+        )?;
+
+        Ok(electrum_update)
+    }
 }

-impl<A: ElectrumApi> ElectrumExt for A {
-    fn full_scan<K: Ord + Clone>(
+impl ElectrumExt for Client {
+    fn scan<K: Ord + Clone>(
        &self,
        prev_tip: CheckPoint,
        keychain_spks: BTreeMap<K, impl IntoIterator<Item = (u32, ScriptBuf)>>,
+        txids: impl IntoIterator<Item = Txid>,
+        outpoints: impl IntoIterator<Item = OutPoint>,
        stop_gap: usize,
        batch_size: usize,
    ) -> Result<(ElectrumUpdate, BTreeMap<K, u32>), Error> {
@@ -188,6 +201,9 @@ impl<A: ElectrumApi> ElectrumExt for A {
            .collect::<BTreeMap<K, _>>();
        let mut scanned_spks = BTreeMap::<(K, u32), (ScriptBuf, bool)>::new();

+        let txids = txids.into_iter().collect::<Vec<_>>();
+        let outpoints = outpoints.into_iter().collect::<Vec<_>>();
+
        let (electrum_update, keychain_update) = loop {
            let (tip, _) = construct_update_tip(self, prev_tip.clone())?;
            let mut relevant_txids = RelevantTxids::default();
@@ -226,6 +242,15 @@ impl<A: ElectrumApi> ElectrumExt for A {
                }
            }

+            populate_with_txids(self, &cps, &mut relevant_txids, &mut txids.iter().cloned())?;
+
+            let _txs = populate_with_outpoints(
+                self,
+                &cps,
+                &mut relevant_txids,
+                &mut outpoints.iter().cloned(),
+            )?;
+
            // check for reorgs during scan process
            let server_blockhash = self.block_header(tip.height() as usize)?.block_hash();
            if tip.hash() != server_blockhash {
@@ -259,46 +284,11 @@ impl<A: ElectrumApi> ElectrumExt for A {

        Ok((electrum_update, keychain_update))
    }
-
-    fn sync(
-        &self,
-        prev_tip: CheckPoint,
-        misc_spks: impl IntoIterator<Item = ScriptBuf>,
-        txids: impl IntoIterator<Item = Txid>,
-        outpoints: impl IntoIterator<Item = OutPoint>,
-        batch_size: usize,
-    ) -> Result<ElectrumUpdate, Error> {
-        let spk_iter = misc_spks
-            .into_iter()
-            .enumerate()
-            .map(|(i, spk)| (i as u32, spk));
-
-        let (mut electrum_update, _) = self.full_scan(
-            prev_tip.clone(),
-            [((), spk_iter)].into(),
-            usize::MAX,
-            batch_size,
-        )?;
-
-        let (tip, _) = construct_update_tip(self, prev_tip)?;
-        let cps = tip
-            .iter()
-            .take(10)
-            .map(|cp| (cp.height(), cp))
-            .collect::<BTreeMap<u32, CheckPoint>>();
-
-        populate_with_txids(self, &cps, &mut electrum_update.relevant_txids, txids)?;
-
-        let _txs =
-            populate_with_outpoints(self, &cps, &mut electrum_update.relevant_txids, outpoints)?;
-
-        Ok(electrum_update)
-    }
 }

 /// Return a [`CheckPoint`] of the latest tip, that connects with `prev_tip`.
 fn construct_update_tip(
-    client: &impl ElectrumApi,
+    client: &Client,
    prev_tip: CheckPoint,
 ) -> Result<(CheckPoint, Option<u32>), Error> {
    let HeaderNotification { height, .. } = client.block_headers_subscribe()?;
@@ -412,10 +402,10 @@ fn determine_tx_anchor(
 }

 fn populate_with_outpoints(
-    client: &impl ElectrumApi,
+    client: &Client,
    cps: &BTreeMap<u32, CheckPoint>,
    relevant_txids: &mut RelevantTxids,
-    outpoints: impl IntoIterator<Item = OutPoint>,
+    outpoints: &mut impl Iterator<Item = OutPoint>,
 ) -> Result<HashMap<Txid, Transaction>, Error> {
    let mut full_txs = HashMap::new();
    for outpoint in outpoints {
@@ -473,10 +463,10 @@ fn populate_with_outpoints(
 }

 fn populate_with_txids(
-    client: &impl ElectrumApi,
+    client: &Client,
    cps: &BTreeMap<u32, CheckPoint>,
    relevant_txids: &mut RelevantTxids,
-    txids: impl IntoIterator<Item = Txid>,
+    txids: &mut impl Iterator<Item = Txid>,
 ) -> Result<(), Error> {
    for txid in txids {
        let tx = match client.transaction_get(&txid) {
@@ -487,7 +477,7 @@ fn populate_with_txids(

        let spk = tx
            .output
-            .first()
+            .get(0)
            .map(|txo| &txo.script_pubkey)
            .expect("tx must have an output");

@@ -509,7 +499,7 @@ fn populate_with_txids(
 }

 fn populate_with_spks<I: Ord + Clone>(
-    client: &impl ElectrumApi,
+    client: &Client,
    cps: &BTreeMap<u32, CheckPoint>,
    relevant_txids: &mut RelevantTxids,
    spks: &mut impl Iterator<Item = (I, ScriptBuf)>,
--- a/crates/electrum/src/lib.rs
+++ b/crates/electrum/src/lib.rs
@@ -1,26 +1,26 @@
-//! This crate is used for updating structures of [`bdk_chain`] with data from an Electrum server.
+//! This crate is used for updating structures of the [`bdk_chain`] crate with data from electrum.
 //!
-//! The two primary methods are [`ElectrumExt::sync`] and [`ElectrumExt::full_scan`]. In most cases
-//! [`ElectrumExt::sync`] is used to sync the transaction histories of scripts that the application
-//! cares about, for example the scripts for all the receive addresses of a Wallet's keychain that it
-//! has shown a user. [`ElectrumExt::full_scan`] is meant to be used when importing or restoring a
-//! keychain where the range of possibly used scripts is not known. In this case it is necessary to
-//! scan all keychain scripts until a number (the "stop gap") of unused scripts is discovered. For a
-//! sync or full scan the user receives relevant blockchain data and output updates for
-//! [`bdk_chain`] including [`RelevantTxids`].
+//! The star of the show is the [`ElectrumExt::scan`] method, which scans for relevant blockchain
+//! data (via electrum) and outputs updates for [`bdk_chain`] structures as a tuple of form:
 //!
-//! The [`RelevantTxids`] only includes `txid`s and not full transactions. The caller is responsible
-//! for obtaining full transactions before applying new data to their [`bdk_chain`]. This can be
-//! done with these steps:
+//! ([`bdk_chain::local_chain::Update`], [`RelevantTxids`], `keychain_update`)
 //!
-//! 1. Determine which full transactions are missing. Use [`RelevantTxids::missing_full_txs`].
+//! An [`RelevantTxids`] only includes `txid`s and no full transactions. The caller is
+//! responsible for obtaining full transactions before applying. This can be done with
+//! these steps:
 //!
-//! 2. Obtaining the full transactions. To do this via electrum use [`ElectrumApi::batch_transaction_get`].
+//! 1. Determine which full transactions are missing. The method [`missing_full_txs`] of
+//! [`RelevantTxids`] can be used.
 //!
-//! Refer to [`example_electrum`] for a complete example.
+//! 2. Obtaining the full transactions. To do this via electrum, the method
+//! [`batch_transaction_get`] can be used.
 //!
-//! [`ElectrumApi::batch_transaction_get`]: electrum_client::ElectrumApi::batch_transaction_get
-//! [`example_electrum`]: https://github.com/bitcoindevkit/bdk/tree/master/example-crates/example_electrum
+//! Refer to [`bdk_electrum_example`] for a complete example.
+//!
+//! [`ElectrumClient::scan`]: electrum_client::ElectrumClient::scan
+//! [`missing_full_txs`]: RelevantTxids::missing_full_txs
+//! [`batch_transaction_get`]: electrum_client::ElectrumApi::batch_transaction_get
+//! [`bdk_electrum_example`]: https://github.com/LLFourn/bdk_core_staging/tree/master/bdk_electrum_example

 #![warn(missing_docs)]

--- a/crates/electrum/tests/test_electrum.rs
+++ b/crates/electrum/tests/test_electrum.rs
@@ -1,191 +0,0 @@
-use anyhow::Result;
-use bdk_chain::{
-    bitcoin::{hashes::Hash, Address, Amount, ScriptBuf, WScriptHash},
-    keychain::Balance,
-    local_chain::LocalChain,
-    ConfirmationTimeHeightAnchor, IndexedTxGraph, SpkTxOutIndex,
-};
-use bdk_electrum::{ElectrumExt, ElectrumUpdate};
-use bdk_testenv::TestEnv;
-use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-
-fn get_balance(
-    recv_chain: &LocalChain,
-    recv_graph: &IndexedTxGraph<ConfirmationTimeHeightAnchor, SpkTxOutIndex<()>>,
-) -> Result<Balance> {
-    let chain_tip = recv_chain.tip().block_id();
-    let outpoints = recv_graph.index.outpoints().clone();
-    let balance = recv_graph
-        .graph()
-        .balance(recv_chain, chain_tip, outpoints, |_, _| true);
-    Ok(balance)
-}
-
-/// Ensure that [`ElectrumExt`] can sync properly.
-///
-/// 1. Mine 101 blocks.
-/// 2. Send a tx.
-/// 3. Mine extra block to confirm sent tx.
-/// 4. Check [`Balance`] to ensure tx is confirmed.
-#[test]
-fn scan_detects_confirmed_tx() -> Result<()> {
-    const SEND_AMOUNT: Amount = Amount::from_sat(10_000);
-
-    let env = TestEnv::new()?;
-    let client = electrum_client::Client::new(env.electrsd.electrum_url.as_str())?;
-
-    // Setup addresses.
-    let addr_to_mine = env
-        .bitcoind
-        .client
-        .get_new_address(None, None)?
-        .assume_checked();
-    let spk_to_track = ScriptBuf::new_p2wsh(&WScriptHash::all_zeros());
-    let addr_to_track = Address::from_script(&spk_to_track, bdk_chain::bitcoin::Network::Regtest)?;
-
-    // Setup receiver.
-    let (mut recv_chain, _) = LocalChain::from_genesis_hash(env.bitcoind.client.get_block_hash(0)?);
-    let mut recv_graph = IndexedTxGraph::<ConfirmationTimeHeightAnchor, _>::new({
-        let mut recv_index = SpkTxOutIndex::default();
-        recv_index.insert_spk((), spk_to_track.clone());
-        recv_index
-    });
-
-    // Mine some blocks.
-    env.mine_blocks(101, Some(addr_to_mine))?;
-
-    // Create transaction that is tracked by our receiver.
-    env.send(&addr_to_track, SEND_AMOUNT)?;
-
-    // Mine a block to confirm sent tx.
-    env.mine_blocks(1, None)?;
-
-    // Sync up to tip.
-    env.wait_until_electrum_sees_block()?;
-    let ElectrumUpdate {
-        chain_update,
-        relevant_txids,
-    } = client.sync(recv_chain.tip(), [spk_to_track], None, None, 5)?;
-
-    let missing = relevant_txids.missing_full_txs(recv_graph.graph());
-    let graph_update = relevant_txids.into_confirmation_time_tx_graph(&client, missing)?;
-    let _ = recv_chain
-        .apply_update(chain_update)
-        .map_err(|err| anyhow::anyhow!("LocalChain update error: {:?}", err))?;
-    let _ = recv_graph.apply_update(graph_update);
-
-    // Check to see if tx is confirmed.
-    assert_eq!(
-        get_balance(&recv_chain, &recv_graph)?,
-        Balance {
-            confirmed: SEND_AMOUNT.to_sat(),
-            ..Balance::default()
-        },
-    );
-
-    Ok(())
-}
-
-/// Ensure that confirmed txs that are reorged become unconfirmed.
-///
-/// 1. Mine 101 blocks.
-/// 2. Mine 8 blocks with a confirmed tx in each.
-/// 3. Perform 8 separate reorgs on each block with a confirmed tx.
-/// 4. Check [`Balance`] after each reorg to ensure unconfirmed amount is correct.
-#[test]
-fn tx_can_become_unconfirmed_after_reorg() -> Result<()> {
-    const REORG_COUNT: usize = 8;
-    const SEND_AMOUNT: Amount = Amount::from_sat(10_000);
-
-    let env = TestEnv::new()?;
-    let client = electrum_client::Client::new(env.electrsd.electrum_url.as_str())?;
-
-    // Setup addresses.
-    let addr_to_mine = env
-        .bitcoind
-        .client
-        .get_new_address(None, None)?
-        .assume_checked();
-    let spk_to_track = ScriptBuf::new_p2wsh(&WScriptHash::all_zeros());
-    let addr_to_track = Address::from_script(&spk_to_track, bdk_chain::bitcoin::Network::Regtest)?;
-
-    // Setup receiver.
-    let (mut recv_chain, _) = LocalChain::from_genesis_hash(env.bitcoind.client.get_block_hash(0)?);
-    let mut recv_graph = IndexedTxGraph::<ConfirmationTimeHeightAnchor, _>::new({
-        let mut recv_index = SpkTxOutIndex::default();
-        recv_index.insert_spk((), spk_to_track.clone());
-        recv_index
-    });
-
-    // Mine some blocks.
-    env.mine_blocks(101, Some(addr_to_mine))?;
-
-    // Create transactions that are tracked by our receiver.
-    for _ in 0..REORG_COUNT {
-        env.send(&addr_to_track, SEND_AMOUNT)?;
-        env.mine_blocks(1, None)?;
-    }
-
-    // Sync up to tip.
-    env.wait_until_electrum_sees_block()?;
-    let ElectrumUpdate {
-        chain_update,
-        relevant_txids,
-    } = client.sync(recv_chain.tip(), [spk_to_track.clone()], None, None, 5)?;
-
-    let missing = relevant_txids.missing_full_txs(recv_graph.graph());
-    let graph_update = relevant_txids.into_confirmation_time_tx_graph(&client, missing)?;
-    let _ = recv_chain
-        .apply_update(chain_update)
-        .map_err(|err| anyhow::anyhow!("LocalChain update error: {:?}", err))?;
-    let _ = recv_graph.apply_update(graph_update.clone());
-
-    // Retain a snapshot of all anchors before reorg process.
-    let initial_anchors = graph_update.all_anchors();
-
-    // Check if initial balance is correct.
-    assert_eq!(
-        get_balance(&recv_chain, &recv_graph)?,
-        Balance {
-            confirmed: SEND_AMOUNT.to_sat() * REORG_COUNT as u64,
-            ..Balance::default()
-        },
-        "initial balance must be correct",
-    );
-
-    // Perform reorgs with different depths.
-    for depth in 1..=REORG_COUNT {
-        env.reorg_empty_blocks(depth)?;
-
-        env.wait_until_electrum_sees_block()?;
-        let ElectrumUpdate {
-            chain_update,
-            relevant_txids,
-        } = client.sync(recv_chain.tip(), [spk_to_track.clone()], None, None, 5)?;
-
-        let missing = relevant_txids.missing_full_txs(recv_graph.graph());
-        let graph_update = relevant_txids.into_confirmation_time_tx_graph(&client, missing)?;
-        let _ = recv_chain
-            .apply_update(chain_update)
-            .map_err(|err| anyhow::anyhow!("LocalChain update error: {:?}", err))?;
-
-        // Check to see if a new anchor is added during current reorg.
-        if !initial_anchors.is_superset(graph_update.all_anchors()) {
-            println!("New anchor added at reorg depth {}", depth);
-        }
-        let _ = recv_graph.apply_update(graph_update);
-
-        assert_eq!(
-            get_balance(&recv_chain, &recv_graph)?,
-            Balance {
-                confirmed: SEND_AMOUNT.to_sat() * (REORG_COUNT - depth) as u64,
-                trusted_pending: SEND_AMOUNT.to_sat() * depth as u64,
-                ..Balance::default()
-            },
-            "reorg_count: {}",
-            depth,
-        );
-    }
-
-    Ok(())
-}
--- a/crates/esplora/Cargo.toml
+++ b/crates/esplora/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_esplora"
-version = "0.11.0"
+version = "0.4.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -12,18 +12,17 @@ readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bdk_chain = { path = "../chain", version = "0.12.0", default-features = false }
-esplora-client = { version = "0.7.0", default-features = false }
+bdk_chain = { path = "../chain", version = "0.6.0", default-features = false }
+esplora-client = { version = "0.6.0", default-features = false }
 async-trait = { version = "0.1.66", optional = true }
 futures = { version = "0.3.26", optional = true }

 # use these dependencies if you need to enable their /no-std features
-bitcoin = { version = "0.31.0", optional = true, default-features = false }
-miniscript = { version = "11.0.0", optional = true, default-features = false }
+bitcoin = { version = "0.30.0", optional = true, default-features = false }
+miniscript = { version = "10.0.0", optional = true, default-features = false }

-[dev-dependencies]
-bdk_testenv = { path = "../testenv", default_features = false }
-electrsd = { version= "0.27.1", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+electrsd = { version= "0.25.0", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }

 [features]
--- a/crates/esplora/README.md
+++ b/crates/esplora/README.md
@@ -30,7 +30,7 @@ use bdk_esplora::EsploraExt;
 // use bdk_esplora::EsploraAsyncExt;
 ```

-For full examples, refer to [`example-crates/wallet_esplora_blocking`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora_blocking) and [`example-crates/wallet_esplora_async`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora_async).
+For full examples, refer to [`example-crates/wallet_esplora`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora) (blocking) and [`example-crates/wallet_esplora_async`](https://github.com/bitcoindevkit/bdk/tree/master/example-crates/wallet_esplora_async).

 [`esplora-client`]: https://docs.rs/esplora-client/
 [`bdk_chain`]: https://docs.rs/bdk-chain/
--- a/crates/esplora/src/async_ext.rs
+++ b/crates/esplora/src/async_ext.rs
@@ -1,18 +1,15 @@
 use async_trait::async_trait;
 use bdk_chain::collections::btree_map;
 use bdk_chain::{
-    bitcoin::{Amount, BlockHash, OutPoint, ScriptBuf, TxOut, Txid},
-    collections::BTreeMap,
+    bitcoin::{BlockHash, OutPoint, ScriptBuf, Txid},
+    collections::{BTreeMap, BTreeSet},
    local_chain::{self, CheckPoint},
    BlockId, ConfirmationTimeHeightAnchor, TxGraph,
 };
-use esplora_client::TxStatus;
+use esplora_client::{Error, TxStatus};
 use futures::{stream::FuturesOrdered, TryStreamExt};

-use crate::anchor_from_status;
-
-/// [`esplora_client::Error`]
-type Error = Box<esplora_client::Error>;
+use crate::{anchor_from_status, ASSUME_FINAL_DEPTH};

 /// Trait to extend the functionality of [`esplora_client::AsyncClient`].
 ///
@@ -22,78 +19,75 @@ type Error = Box<esplora_client::Error>;
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait EsploraAsyncExt {
-    /// Prepare a [`LocalChain`] update with blocks fetched from Esplora.
+    /// Prepare an [`LocalChain`] update with blocks fetched from Esplora.
    ///
    /// * `local_tip` is the previous tip of [`LocalChain::tip`].
    /// * `request_heights` is the block heights that we are interested in fetching from Esplora.
    ///
    /// The result of this method can be applied to [`LocalChain::apply_update`].
    ///
-    /// ## Consistency
-    ///
-    /// The chain update returned is guaranteed to be consistent as long as there is not a *large* re-org
-    /// during the call. The size of re-org we can tollerate is server dependent but will be at
-    /// least 10.
-    ///
    /// [`LocalChain`]: bdk_chain::local_chain::LocalChain
    /// [`LocalChain::tip`]: bdk_chain::local_chain::LocalChain::tip
    /// [`LocalChain::apply_update`]: bdk_chain::local_chain::LocalChain::apply_update
+    #[allow(clippy::result_large_err)]
    async fn update_local_chain(
        &self,
        local_tip: CheckPoint,
        request_heights: impl IntoIterator<IntoIter = impl Iterator<Item = u32> + Send> + Send,
    ) -> Result<local_chain::Update, Error>;

-    /// Full scan the keychain scripts specified with the blockchain (via an Esplora client) and
-    /// returns a [`TxGraph`] and a map of last active indices.
+    /// Scan Esplora for the data specified and return a [`TxGraph`] and a map of last active
+    /// indices.
    ///
    /// * `keychain_spks`: keychains that we want to scan transactions for
+    /// * `txids`: transactions for which we want updated [`ConfirmationTimeHeightAnchor`]s
+    /// * `outpoints`: transactions associated with these outpoints (residing, spending) that we
+    ///     want to include in the update
    ///
-    /// The full scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
+    /// The scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
    /// transactions. `parallel_requests` specifies the max number of HTTP requests to make in
    /// parallel.
-    ///
-    /// ## Note
-    ///
-    /// `stop_gap` is defined as "the maximum number of consecutive unused addresses".
-    /// For example, with a `stop_gap` of  3, `full_scan` will keep scanning
-    /// until it encounters 3 consecutive script pubkeys with no associated transactions.
-    ///
-    /// This follows the same approach as other Bitcoin-related software,
-    /// such as [Electrum](https://electrum.readthedocs.io/en/latest/faq.html#what-is-the-gap-limit),
-    /// [BTCPay Server](https://docs.btcpayserver.org/FAQ/Wallet/#the-gap-limit-problem),
-    /// and [Sparrow](https://www.sparrowwallet.com/docs/faq.html#ive-restored-my-wallet-but-some-of-my-funds-are-missing).
-    ///
-    /// A `stop_gap` of 0 will be treated as a `stop_gap` of 1.
-    async fn full_scan<K: Ord + Clone + Send>(
+    #[allow(clippy::result_large_err)]
+    async fn scan_txs_with_keychains<K: Ord + Clone + Send>(
        &self,
        keychain_spks: BTreeMap<
            K,
            impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send> + Send,
        >,
+        txids: impl IntoIterator<IntoIter = impl Iterator<Item = Txid> + Send> + Send,
+        outpoints: impl IntoIterator<IntoIter = impl Iterator<Item = OutPoint> + Send> + Send,
        stop_gap: usize,
        parallel_requests: usize,
    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error>;

-    /// Sync a set of scripts with the blockchain (via an Esplora client) for the data
-    /// specified and return a [`TxGraph`].
+    /// Convenience method to call [`scan_txs_with_keychains`] without requiring a keychain.
    ///
-    /// * `misc_spks`: scripts that we want to sync transactions for
-    /// * `txids`: transactions for which we want updated [`ConfirmationTimeHeightAnchor`]s
-    /// * `outpoints`: transactions associated with these outpoints (residing, spending) that we
-    ///     want to include in the update
-    ///
-    /// If the scripts to sync are unknown, such as when restoring or importing a keychain that
-    /// may include scripts that have been used, use [`full_scan`] with the keychain.
-    ///
-    /// [`full_scan`]: EsploraAsyncExt::full_scan
-    async fn sync(
+    /// [`scan_txs_with_keychains`]: EsploraAsyncExt::scan_txs_with_keychains
+    #[allow(clippy::result_large_err)]
+    async fn scan_txs(
        &self,
        misc_spks: impl IntoIterator<IntoIter = impl Iterator<Item = ScriptBuf> + Send> + Send,
        txids: impl IntoIterator<IntoIter = impl Iterator<Item = Txid> + Send> + Send,
        outpoints: impl IntoIterator<IntoIter = impl Iterator<Item = OutPoint> + Send> + Send,
        parallel_requests: usize,
-    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error>;
+    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
+        self.scan_txs_with_keychains(
+            [(
+                (),
+                misc_spks
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, spk)| (i as u32, spk)),
+            )]
+            .into(),
+            txids,
+            outpoints,
+            usize::MAX,
+            parallel_requests,
+        )
+        .await
+        .map(|(g, _)| g)
+    }
 }

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -104,22 +98,21 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
        local_tip: CheckPoint,
        request_heights: impl IntoIterator<IntoIter = impl Iterator<Item = u32> + Send> + Send,
    ) -> Result<local_chain::Update, Error> {
-        // Fetch latest N (server dependent) blocks from Esplora. The server guarantees these are
-        // consistent.
-        let mut fetched_blocks = self
-            .get_blocks(None)
-            .await?
-            .into_iter()
-            .map(|b| (b.time.height, b.id))
-            .collect::<BTreeMap<u32, BlockHash>>();
-        let new_tip_height = fetched_blocks
-            .keys()
-            .last()
-            .copied()
-            .expect("must have atleast one block");
+        let request_heights = request_heights.into_iter().collect::<BTreeSet<_>>();
+        let new_tip_height = self.get_height().await?;

-        // Fetch blocks of heights that the caller is interested in, skipping blocks that are
-        // already fetched when constructing `fetched_blocks`.
+        // atomically fetch blocks from esplora
+        let mut fetched_blocks = {
+            let heights = (0..=new_tip_height).rev();
+            let hashes = self
+                .get_blocks(Some(new_tip_height))
+                .await?
+                .into_iter()
+                .map(|b| b.id);
+            heights.zip(hashes).collect::<BTreeMap<u32, BlockHash>>()
+        };
+
+        // fetch heights that the caller is interested in
        for height in request_heights {
            // do not fetch blocks higher than remote tip
            if height > new_tip_height {
@@ -127,47 +120,93 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
            }
            // only fetch what is missing
            if let btree_map::Entry::Vacant(entry) = fetched_blocks.entry(height) {
-                // ❗The return value of `get_block_hash` is not strictly guaranteed to be consistent
-                // with the chain at the time of `get_blocks` above (there could have been a deep
-                // re-org). Since `get_blocks` returns 10 (or so) blocks we are assuming that it's
-                // not possible to have a re-org deeper than that.
-                entry.insert(self.get_block_hash(height).await?);
+                let hash = self.get_block_hash(height).await?;
+                entry.insert(hash);
            }
        }

-        // Ensure `fetched_blocks` can create an update that connects with the original chain by
-        // finding a "Point of Agreement".
-        for (height, local_hash) in local_tip.iter().map(|cp| (cp.height(), cp.hash())) {
-            if height > new_tip_height {
-                continue;
+        // find the earliest point of agreement between local chain and fetched chain
+        let earliest_agreement_cp = {
+            let mut earliest_agreement_cp = Option::<CheckPoint>::None;
+
+            let local_tip_height = local_tip.height();
+            for local_cp in local_tip.iter() {
+                let local_block = local_cp.block_id();
+
+                // the updated hash (block hash at this height after the update), can either be:
+                // 1. a block that already existed in `fetched_blocks`
+                // 2. a block that exists locally and at least has a depth of ASSUME_FINAL_DEPTH
+                // 3. otherwise we can freshly fetch the block from remote, which is safe as it
+                //    is guaranteed that this would be at or below ASSUME_FINAL_DEPTH from the
+                //    remote tip
+                let updated_hash = match fetched_blocks.entry(local_block.height) {
+                    btree_map::Entry::Occupied(entry) => *entry.get(),
+                    btree_map::Entry::Vacant(entry) => *entry.insert(
+                        if local_tip_height - local_block.height >= ASSUME_FINAL_DEPTH {
+                            local_block.hash
+                        } else {
+                            self.get_block_hash(local_block.height).await?
+                        },
+                    ),
+                };
+
+                // since we may introduce blocks below the point of agreement, we cannot break
+                // here unconditionally - we only break if we guarantee there are no new heights
+                // below our current local checkpoint
+                if local_block.hash == updated_hash {
+                    earliest_agreement_cp = Some(local_cp);
+
+                    let first_new_height = *fetched_blocks
+                        .keys()
+                        .next()
+                        .expect("must have at least one new block");
+                    if first_new_height >= local_block.height {
+                        break;
+                    }
+                }
            }

-            let fetched_hash = match fetched_blocks.entry(height) {
-                btree_map::Entry::Occupied(entry) => *entry.get(),
-                btree_map::Entry::Vacant(entry) => {
-                    *entry.insert(self.get_block_hash(height).await?)
+            earliest_agreement_cp
+        };
+
+        let tip = {
+            // first checkpoint to use for the update chain
+            let first_cp = match earliest_agreement_cp {
+                Some(cp) => cp,
+                None => {
+                    let (&height, &hash) = fetched_blocks
+                        .iter()
+                        .next()
+                        .expect("must have at least one new block");
+                    CheckPoint::new(BlockId { height, hash })
                }
            };
-
-            // We have found point of agreement so the update will connect!
-            if fetched_hash == local_hash {
-                break;
-            }
-        }
+            // transform fetched chain into the update chain
+            fetched_blocks
+                // we exclude anything at or below the first cp of the update chain otherwise
+                // building the chain will fail
+                .split_off(&(first_cp.height() + 1))
+                .into_iter()
+                .map(|(height, hash)| BlockId { height, hash })
+                .fold(first_cp, |prev_cp, block| {
+                    prev_cp.push(block).expect("must extend checkpoint")
+                })
+        };

        Ok(local_chain::Update {
-            tip: CheckPoint::from_block_ids(fetched_blocks.into_iter().map(BlockId::from))
-                .expect("must be in height order"),
+            tip,
            introduce_older_blocks: true,
        })
    }

-    async fn full_scan<K: Ord + Clone + Send>(
+    async fn scan_txs_with_keychains<K: Ord + Clone + Send>(
        &self,
        keychain_spks: BTreeMap<
            K,
            impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send> + Send,
        >,
+        txids: impl IntoIterator<IntoIter = impl Iterator<Item = Txid> + Send> + Send,
+        outpoints: impl IntoIterator<IntoIter = impl Iterator<Item = OutPoint> + Send> + Send,
        stop_gap: usize,
        parallel_requests: usize,
    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error> {
@@ -175,7 +214,6 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
        let parallel_requests = Ord::max(parallel_requests, 1);
        let mut graph = TxGraph::<ConfirmationTimeHeightAnchor>::default();
        let mut last_active_indexes = BTreeMap::<K, u32>::new();
-        let stop_gap = Ord::max(stop_gap, 1);

        for (keychain, spks) in keychain_spks {
            let mut spks = spks.into_iter();
@@ -218,34 +256,16 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
                        if let Some(anchor) = anchor_from_status(&tx.status) {
                            let _ = graph.insert_anchor(tx.txid, anchor);
                        }
-
-                        let previous_outputs = tx.vin.iter().filter_map(|vin| {
-                            let prevout = vin.prevout.as_ref()?;
-                            Some((
-                                OutPoint {
-                                    txid: vin.txid,
-                                    vout: vin.vout,
-                                },
-                                TxOut {
-                                    script_pubkey: prevout.scriptpubkey.clone(),
-                                    value: Amount::from_sat(prevout.value),
-                                },
-                            ))
-                        });
-
-                        for (outpoint, txout) in previous_outputs {
-                            let _ = graph.insert_txout(outpoint, txout);
-                        }
                    }
                }

                let last_index = last_index.expect("Must be set since handles wasn't empty.");
-                let gap_limit_reached = if let Some(i) = last_active_index {
-                    last_index >= i.saturating_add(stop_gap as u32)
+                let past_gap_limit = if let Some(i) = last_active_index {
+                    last_index > i.saturating_add(stop_gap as u32)
                } else {
-                    last_index + 1 >= stop_gap as u32
+                    last_index >= stop_gap as u32
                };
-                if gap_limit_reached {
+                if past_gap_limit {
                    break;
                }
            }
@@ -255,32 +275,6 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
            }
        }

-        Ok((graph, last_active_indexes))
-    }
-
-    async fn sync(
-        &self,
-        misc_spks: impl IntoIterator<IntoIter = impl Iterator<Item = ScriptBuf> + Send> + Send,
-        txids: impl IntoIterator<IntoIter = impl Iterator<Item = Txid> + Send> + Send,
-        outpoints: impl IntoIterator<IntoIter = impl Iterator<Item = OutPoint> + Send> + Send,
-        parallel_requests: usize,
-    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
-        let mut graph = self
-            .full_scan(
-                [(
-                    (),
-                    misc_spks
-                        .into_iter()
-                        .enumerate()
-                        .map(|(i, spk)| (i as u32, spk)),
-                )]
-                .into(),
-                usize::MAX,
-                parallel_requests,
-            )
-            .await
-            .map(|(g, _)| g)?;
-
        let mut txids = txids.into_iter();
        loop {
            let handles = txids
@@ -329,6 +323,7 @@ impl EsploraAsyncExt for esplora_client::AsyncClient {
                }
            }
        }
-        Ok(graph)
+
+        Ok((graph, last_active_indexes))
    }
 }
--- a/crates/esplora/src/blocking_ext.rs
+++ b/crates/esplora/src/blocking_ext.rs
@@ -1,18 +1,15 @@
 use std::thread::JoinHandle;

 use bdk_chain::collections::btree_map;
-use bdk_chain::collections::BTreeMap;
+use bdk_chain::collections::{BTreeMap, BTreeSet};
 use bdk_chain::{
-    bitcoin::{Amount, BlockHash, OutPoint, ScriptBuf, TxOut, Txid},
+    bitcoin::{BlockHash, OutPoint, ScriptBuf, Txid},
    local_chain::{self, CheckPoint},
    BlockId, ConfirmationTimeHeightAnchor, TxGraph,
 };
-use esplora_client::TxStatus;
+use esplora_client::{Error, TxStatus};

-use crate::anchor_from_status;
-
-/// [`esplora_client::Error`]
-type Error = Box<esplora_client::Error>;
+use crate::{anchor_from_status, ASSUME_FINAL_DEPTH};

 /// Trait to extend the functionality of [`esplora_client::BlockingClient`].
 ///
@@ -20,75 +17,71 @@ type Error = Box<esplora_client::Error>;
 ///
 /// [crate-level documentation]: crate
 pub trait EsploraExt {
-    /// Prepare a [`LocalChain`] update with blocks fetched from Esplora.
+    /// Prepare an [`LocalChain`] update with blocks fetched from Esplora.
    ///
-    /// * `local_tip` is the previous tip of [`LocalChain::tip`].
-    /// * `request_heights` is the block heights that we are interested in fetching from Esplora.
+    /// * `prev_tip` is the previous tip of [`LocalChain::tip`].
+    /// * `get_heights` is the block heights that we are interested in fetching from Esplora.
    ///
    /// The result of this method can be applied to [`LocalChain::apply_update`].
    ///
-    /// ## Consistency
-    ///
-    /// The chain update returned is guaranteed to be consistent as long as there is not a *large* re-org
-    /// during the call. The size of re-org we can tollerate is server dependent but will be at
-    /// least 10.
-    ///
    /// [`LocalChain`]: bdk_chain::local_chain::LocalChain
    /// [`LocalChain::tip`]: bdk_chain::local_chain::LocalChain::tip
    /// [`LocalChain::apply_update`]: bdk_chain::local_chain::LocalChain::apply_update
+    #[allow(clippy::result_large_err)]
    fn update_local_chain(
        &self,
        local_tip: CheckPoint,
        request_heights: impl IntoIterator<Item = u32>,
    ) -> Result<local_chain::Update, Error>;

-    /// Full scan the keychain scripts specified with the blockchain (via an Esplora client) and
-    /// returns a [`TxGraph`] and a map of last active indices.
+    /// Scan Esplora for the data specified and return a [`TxGraph`] and a map of last active
+    /// indices.
    ///
    /// * `keychain_spks`: keychains that we want to scan transactions for
-    ///
-    /// The full scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
-    /// transactions. `parallel_requests` specifies the max number of HTTP requests to make in
-    /// parallel.
-    ///
-    /// ## Note
-    ///
-    /// `stop_gap` is defined as "the maximum number of consecutive unused addresses".
-    /// For example, with a `stop_gap` of  3, `full_scan` will keep scanning
-    /// until it encounters 3 consecutive script pubkeys with no associated transactions.
-    ///
-    /// This follows the same approach as other Bitcoin-related software,
-    /// such as [Electrum](https://electrum.readthedocs.io/en/latest/faq.html#what-is-the-gap-limit),
-    /// [BTCPay Server](https://docs.btcpayserver.org/FAQ/Wallet/#the-gap-limit-problem),
-    /// and [Sparrow](https://www.sparrowwallet.com/docs/faq.html#ive-restored-my-wallet-but-some-of-my-funds-are-missing).
-    ///
-    /// A `stop_gap` of 0 will be treated as a `stop_gap` of 1.
-    fn full_scan<K: Ord + Clone>(
-        &self,
-        keychain_spks: BTreeMap<K, impl IntoIterator<Item = (u32, ScriptBuf)>>,
-        stop_gap: usize,
-        parallel_requests: usize,
-    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error>;
-
-    /// Sync a set of scripts with the blockchain (via an Esplora client) for the data
-    /// specified and return a [`TxGraph`].
-    ///
-    /// * `misc_spks`: scripts that we want to sync transactions for
    /// * `txids`: transactions for which we want updated [`ConfirmationTimeHeightAnchor`]s
    /// * `outpoints`: transactions associated with these outpoints (residing, spending) that we
    ///     want to include in the update
    ///
-    /// If the scripts to sync are unknown, such as when restoring or importing a keychain that
-    /// may include scripts that have been used, use [`full_scan`] with the keychain.
+    /// The scan for each keychain stops after a gap of `stop_gap` script pubkeys with no associated
+    /// transactions. `parallel_requests` specifies the max number of HTTP requests to make in
+    /// parallel.
+    #[allow(clippy::result_large_err)]
+    fn scan_txs_with_keychains<K: Ord + Clone>(
+        &self,
+        keychain_spks: BTreeMap<K, impl IntoIterator<Item = (u32, ScriptBuf)>>,
+        txids: impl IntoIterator<Item = Txid>,
+        outpoints: impl IntoIterator<Item = OutPoint>,
+        stop_gap: usize,
+        parallel_requests: usize,
+    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error>;
+
+    /// Convenience method to call [`scan_txs_with_keychains`] without requiring a keychain.
    ///
-    /// [`full_scan`]: EsploraExt::full_scan
-    fn sync(
+    /// [`scan_txs_with_keychains`]: EsploraExt::scan_txs_with_keychains
+    #[allow(clippy::result_large_err)]
+    fn scan_txs(
        &self,
        misc_spks: impl IntoIterator<Item = ScriptBuf>,
        txids: impl IntoIterator<Item = Txid>,
        outpoints: impl IntoIterator<Item = OutPoint>,
        parallel_requests: usize,
-    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error>;
+    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
+        self.scan_txs_with_keychains(
+            [(
+                (),
+                misc_spks
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, spk)| (i as u32, spk)),
+            )]
+            .into(),
+            txids,
+            outpoints,
+            usize::MAX,
+            parallel_requests,
+        )
+        .map(|(g, _)| g)
+    }
 }

 impl EsploraExt for esplora_client::BlockingClient {
@@ -97,21 +90,20 @@ impl EsploraExt for esplora_client::BlockingClient {
        local_tip: CheckPoint,
        request_heights: impl IntoIterator<Item = u32>,
    ) -> Result<local_chain::Update, Error> {
-        // Fetch latest N (server dependent) blocks from Esplora. The server guarantees these are
-        // consistent.
-        let mut fetched_blocks = self
-            .get_blocks(None)?
-            .into_iter()
-            .map(|b| (b.time.height, b.id))
-            .collect::<BTreeMap<u32, BlockHash>>();
-        let new_tip_height = fetched_blocks
-            .keys()
-            .last()
-            .copied()
-            .expect("must atleast have one block");
+        let request_heights = request_heights.into_iter().collect::<BTreeSet<_>>();
+        let new_tip_height = self.get_height()?;

-        // Fetch blocks of heights that the caller is interested in, skipping blocks that are
-        // already fetched when constructing `fetched_blocks`.
+        // atomically fetch blocks from esplora
+        let mut fetched_blocks = {
+            let heights = (0..=new_tip_height).rev();
+            let hashes = self
+                .get_blocks(Some(new_tip_height))?
+                .into_iter()
+                .map(|b| b.id);
+            heights.zip(hashes).collect::<BTreeMap<u32, BlockHash>>()
+        };
+
+        // fetch heights that the caller is interested in
        for height in request_heights {
            // do not fetch blocks higher than remote tip
            if height > new_tip_height {
@@ -119,42 +111,90 @@ impl EsploraExt for esplora_client::BlockingClient {
            }
            // only fetch what is missing
            if let btree_map::Entry::Vacant(entry) = fetched_blocks.entry(height) {
-                // ❗The return value of `get_block_hash` is not strictly guaranteed to be consistent
-                // with the chain at the time of `get_blocks` above (there could have been a deep
-                // re-org). Since `get_blocks` returns 10 (or so) blocks we are assuming that it's
-                // not possible to have a re-org deeper than that.
-                entry.insert(self.get_block_hash(height)?);
+                let hash = self.get_block_hash(height)?;
+                entry.insert(hash);
            }
        }

-        // Ensure `fetched_blocks` can create an update that connects with the original chain by
-        // finding a "Point of Agreement".
-        for (height, local_hash) in local_tip.iter().map(|cp| (cp.height(), cp.hash())) {
-            if height > new_tip_height {
-                continue;
+        // find the earliest point of agreement between local chain and fetched chain
+        let earliest_agreement_cp = {
+            let mut earliest_agreement_cp = Option::<CheckPoint>::None;
+
+            let local_tip_height = local_tip.height();
+            for local_cp in local_tip.iter() {
+                let local_block = local_cp.block_id();
+
+                // the updated hash (block hash at this height after the update), can either be:
+                // 1. a block that already existed in `fetched_blocks`
+                // 2. a block that exists locally and at least has a depth of ASSUME_FINAL_DEPTH
+                // 3. otherwise we can freshly fetch the block from remote, which is safe as it
+                //    is guaranteed that this would be at or below ASSUME_FINAL_DEPTH from the
+                //    remote tip
+                let updated_hash = match fetched_blocks.entry(local_block.height) {
+                    btree_map::Entry::Occupied(entry) => *entry.get(),
+                    btree_map::Entry::Vacant(entry) => *entry.insert(
+                        if local_tip_height - local_block.height >= ASSUME_FINAL_DEPTH {
+                            local_block.hash
+                        } else {
+                            self.get_block_hash(local_block.height)?
+                        },
+                    ),
+                };
+
+                // since we may introduce blocks below the point of agreement, we cannot break
+                // here unconditionally - we only break if we guarantee there are no new heights
+                // below our current local checkpoint
+                if local_block.hash == updated_hash {
+                    earliest_agreement_cp = Some(local_cp);
+
+                    let first_new_height = *fetched_blocks
+                        .keys()
+                        .next()
+                        .expect("must have at least one new block");
+                    if first_new_height >= local_block.height {
+                        break;
+                    }
+                }
            }

-            let fetched_hash = match fetched_blocks.entry(height) {
-                btree_map::Entry::Occupied(entry) => *entry.get(),
-                btree_map::Entry::Vacant(entry) => *entry.insert(self.get_block_hash(height)?),
+            earliest_agreement_cp
+        };
+
+        let tip = {
+            // first checkpoint to use for the update chain
+            let first_cp = match earliest_agreement_cp {
+                Some(cp) => cp,
+                None => {
+                    let (&height, &hash) = fetched_blocks
+                        .iter()
+                        .next()
+                        .expect("must have at least one new block");
+                    CheckPoint::new(BlockId { height, hash })
+                }
            };
-
-            // We have found point of agreement so the update will connect!
-            if fetched_hash == local_hash {
-                break;
-            }
-        }
+            // transform fetched chain into the update chain
+            fetched_blocks
+                // we exclude anything at or below the first cp of the update chain otherwise
+                // building the chain will fail
+                .split_off(&(first_cp.height() + 1))
+                .into_iter()
+                .map(|(height, hash)| BlockId { height, hash })
+                .fold(first_cp, |prev_cp, block| {
+                    prev_cp.push(block).expect("must extend checkpoint")
+                })
+        };

        Ok(local_chain::Update {
-            tip: CheckPoint::from_block_ids(fetched_blocks.into_iter().map(BlockId::from))
-                .expect("must be in height order"),
+            tip,
            introduce_older_blocks: true,
        })
    }

-    fn full_scan<K: Ord + Clone>(
+    fn scan_txs_with_keychains<K: Ord + Clone>(
        &self,
        keychain_spks: BTreeMap<K, impl IntoIterator<Item = (u32, ScriptBuf)>>,
+        txids: impl IntoIterator<Item = Txid>,
+        outpoints: impl IntoIterator<Item = OutPoint>,
        stop_gap: usize,
        parallel_requests: usize,
    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error> {
@@ -162,7 +202,6 @@ impl EsploraExt for esplora_client::BlockingClient {
        let parallel_requests = Ord::max(parallel_requests, 1);
        let mut graph = TxGraph::<ConfirmationTimeHeightAnchor>::default();
        let mut last_active_indexes = BTreeMap::<K, u32>::new();
-        let stop_gap = Ord::max(stop_gap, 1);

        for (keychain, spks) in keychain_spks {
            let mut spks = spks.into_iter();
@@ -208,34 +247,16 @@ impl EsploraExt for esplora_client::BlockingClient {
                        if let Some(anchor) = anchor_from_status(&tx.status) {
                            let _ = graph.insert_anchor(tx.txid, anchor);
                        }
-
-                        let previous_outputs = tx.vin.iter().filter_map(|vin| {
-                            let prevout = vin.prevout.as_ref()?;
-                            Some((
-                                OutPoint {
-                                    txid: vin.txid,
-                                    vout: vin.vout,
-                                },
-                                TxOut {
-                                    script_pubkey: prevout.scriptpubkey.clone(),
-                                    value: Amount::from_sat(prevout.value),
-                                },
-                            ))
-                        });
-
-                        for (outpoint, txout) in previous_outputs {
-                            let _ = graph.insert_txout(outpoint, txout);
-                        }
                    }
                }

                let last_index = last_index.expect("Must be set since handles wasn't empty.");
-                let gap_limit_reached = if let Some(i) = last_active_index {
-                    last_index >= i.saturating_add(stop_gap as u32)
+                let past_gap_limit = if let Some(i) = last_active_index {
+                    last_index > i.saturating_add(stop_gap as u32)
                } else {
-                    last_index + 1 >= stop_gap as u32
+                    last_index >= stop_gap as u32
                };
-                if gap_limit_reached {
+                if past_gap_limit {
                    break;
                }
            }
@@ -245,31 +266,6 @@ impl EsploraExt for esplora_client::BlockingClient {
            }
        }

-        Ok((graph, last_active_indexes))
-    }
-
-    fn sync(
-        &self,
-        misc_spks: impl IntoIterator<Item = ScriptBuf>,
-        txids: impl IntoIterator<Item = Txid>,
-        outpoints: impl IntoIterator<Item = OutPoint>,
-        parallel_requests: usize,
-    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
-        let mut graph = self
-            .full_scan(
-                [(
-                    (),
-                    misc_spks
-                        .into_iter()
-                        .enumerate()
-                        .map(|(i, spk)| (i as u32, spk)),
-                )]
-                .into(),
-                usize::MAX,
-                parallel_requests,
-            )
-            .map(|(g, _)| g)?;
-
        let mut txids = txids.into_iter();
        loop {
            let handles = txids
@@ -279,12 +275,7 @@ impl EsploraExt for esplora_client::BlockingClient {
                .map(|txid| {
                    std::thread::spawn({
                        let client = self.clone();
-                        move || {
-                            client
-                                .get_tx_status(&txid)
-                                .map_err(Box::new)
-                                .map(|s| (txid, s))
-                        }
+                        move || client.get_tx_status(&txid).map(|s| (txid, s))
                    })
                })
                .collect::<Vec<JoinHandle<Result<(Txid, TxStatus), Error>>>>();
@@ -301,7 +292,7 @@ impl EsploraExt for esplora_client::BlockingClient {
            }
        }

-        for op in outpoints {
+        for op in outpoints.into_iter() {
            if graph.get_tx(op.txid).is_none() {
                if let Some(tx) = self.get_tx(&op.txid)? {
                    let _ = graph.insert_tx(tx);
@@ -326,6 +317,7 @@ impl EsploraExt for esplora_client::BlockingClient {
                }
            }
        }
-        Ok(graph)
+
+        Ok((graph, last_active_indexes))
    }
 }
--- a/crates/esplora/src/lib.rs
+++ b/crates/esplora/src/lib.rs
@@ -1,21 +1,4 @@
 #![doc = include_str!("../README.md")]
-
-//! This crate is used for updating structures of [`bdk_chain`] with data from an Esplora server.
-//!
-//! The two primary methods are [`EsploraExt::sync`] and [`EsploraExt::full_scan`]. In most cases
-//! [`EsploraExt::sync`] is used to sync the transaction histories of scripts that the application
-//! cares about, for example the scripts for all the receive addresses of a Wallet's keychain that it
-//! has shown a user. [`EsploraExt::full_scan`] is meant to be used when importing or restoring a
-//! keychain where the range of possibly used scripts is not known. In this case it is necessary to
-//! scan all keychain scripts until a number (the "stop gap") of unused scripts is discovered. For a
-//! sync or full scan the user receives relevant blockchain data and output updates for [`bdk_chain`]
-//! via a new [`TxGraph`] to be appended to any existing [`TxGraph`] data.
-//!
-//! Refer to [`example_esplora`] for a complete example.
-//!
-//! [`TxGraph`]: bdk_chain::tx_graph::TxGraph
-//! [`example_esplora`]: https://github.com/bitcoindevkit/bdk/tree/master/example-crates/example_esplora
-
 use bdk_chain::{BlockId, ConfirmationTimeHeightAnchor};
 use esplora_client::TxStatus;

@@ -31,6 +14,8 @@ mod async_ext;
 #[cfg(feature = "async")]
 pub use async_ext::*;

+const ASSUME_FINAL_DEPTH: u32 = 15;
+
 fn anchor_from_status(status: &TxStatus) -> Option<ConfirmationTimeHeightAnchor> {
    if let TxStatus {
        block_height: Some(height),
--- a/crates/esplora/tests/async_ext.rs
+++ b/crates/esplora/tests/async_ext.rs
@@ -1,21 +1,68 @@
 use bdk_esplora::EsploraAsyncExt;
-use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use esplora_client::{self, Builder};
+use electrsd::bitcoind::{self, anyhow, BitcoinD};
+use electrsd::{Conf, ElectrsD};
+use esplora_client::{self, AsyncClient, Builder};
 use std::collections::{BTreeMap, HashSet};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;

-use bdk_chain::bitcoin::{Address, Amount, Txid};
-use bdk_testenv::TestEnv;
+use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};
+
+struct TestEnv {
+    bitcoind: BitcoinD,
+    #[allow(dead_code)]
+    electrsd: ElectrsD,
+    client: AsyncClient,
+}
+
+impl TestEnv {
+    fn new() -> Result<Self, anyhow::Error> {
+        let bitcoind_exe =
+            bitcoind::downloaded_exe_path().expect("bitcoind version feature must be enabled");
+        let bitcoind = BitcoinD::new(bitcoind_exe).unwrap();
+
+        let mut electrs_conf = Conf::default();
+        electrs_conf.http_enabled = true;
+        let electrs_exe =
+            electrsd::downloaded_exe_path().expect("electrs version feature must be enabled");
+        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)?;
+
+        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
+        let client = Builder::new(base_url.as_str()).build_async()?;
+
+        Ok(Self {
+            bitcoind,
+            electrsd,
+            client,
+        })
+    }
+
+    fn mine_blocks(
+        &self,
+        count: usize,
+        address: Option<Address>,
+    ) -> anyhow::Result<Vec<BlockHash>> {
+        let coinbase_address = match address {
+            Some(address) => address,
+            None => self
+                .bitcoind
+                .client
+                .get_new_address(None, None)?
+                .assume_checked(),
+        };
+        let block_hashes = self
+            .bitcoind
+            .client
+            .generate_to_address(count as _, &coinbase_address)?;
+        Ok(block_hashes)
+    }
+}

 #[tokio::test]
 pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    let env = TestEnv::new()?;
-    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-    let client = Builder::new(base_url.as_str()).build_async()?;
-
    let receive_address0 =
        Address::from_str("bcrt1qc6fweuf4xjvz4x3gx3t9e0fh4hvqyu2qw4wvxm")?.assume_checked();
    let receive_address1 =
@@ -48,12 +95,13 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().await.unwrap() < 102 {
+    while env.client.get_height().await.unwrap() < 102 {
        sleep(Duration::from_millis(10))
    }

-    let graph_update = client
-        .sync(
+    let graph_update = env
+        .client
+        .scan_txs(
            misc_spks.into_iter(),
            vec![].into_iter(),
            vec![].into_iter(),
@@ -61,28 +109,6 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
        )
        .await?;

-    // Check to see if we have the floating txouts available from our two created transactions'
-    // previous outputs in order to calculate transaction fees.
-    for tx in graph_update.full_txs() {
-        // Retrieve the calculated fee from `TxGraph`, which will panic if we do not have the
-        // floating txouts available from the transactions' previous outputs.
-        let fee = graph_update.calculate_fee(&tx.tx).expect("Fee must exist");
-
-        // Retrieve the fee in the transaction data from `bitcoind`.
-        let tx_fee = env
-            .bitcoind
-            .client
-            .get_transaction(&tx.txid, None)
-            .expect("Tx must exist")
-            .fee
-            .expect("Fee must exist")
-            .abs()
-            .to_sat() as u64;
-
-        // Check that the calculated fee matches the fee from the transaction data.
-        assert_eq!(fee, tx_fee);
-    }
-
    let mut graph_update_txids: Vec<Txid> = graph_update.full_txs().map(|tx| tx.txid).collect();
    graph_update_txids.sort();
    let mut expected_txids = vec![txid1, txid2];
@@ -91,12 +117,10 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    Ok(())
 }

-/// Test the bounds of the address scan depending on the `stop_gap`.
+/// Test the bounds of the address scan depending on the gap limit.
 #[tokio::test]
-pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
+pub async fn test_async_update_tx_graph_gap_limit() -> anyhow::Result<()> {
    let env = TestEnv::new()?;
-    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-    let client = Builder::new(base_url.as_str()).build_async()?;
    let _block_hashes = env.mine_blocks(101, None)?;

    // Now let's test the gap limit. First of all get a chain of 10 addresses.
@@ -136,16 +160,34 @@ pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().await.unwrap() < 103 {
+    while env.client.get_height().await.unwrap() < 103 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with a gap limit of 3 won't find the transaction, but a scan with a gap limit of 4
+    // A scan with a gap limit of 2 won't find the transaction, but a scan with a gap limit of 3
    // will.
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 3, 1).await?;
+    let (graph_update, active_indices) = env
+        .client
+        .scan_txs_with_keychains(
+            keychains.clone(),
+            vec![].into_iter(),
+            vec![].into_iter(),
+            2,
+            1,
+        )
+        .await?;
    assert!(graph_update.full_txs().next().is_none());
    assert!(active_indices.is_empty());
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 4, 1).await?;
+    let (graph_update, active_indices) = env
+        .client
+        .scan_txs_with_keychains(
+            keychains.clone(),
+            vec![].into_iter(),
+            vec![].into_iter(),
+            3,
+            1,
+        )
+        .await?;
    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
    assert_eq!(active_indices[&0], 3);

@@ -161,18 +203,30 @@ pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().await.unwrap() < 104 {
+    while env.client.get_height().await.unwrap() < 104 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with gap limit 5 won't find the second transaction, but a scan with gap limit 6 will.
+    // A scan with gap limit 4 won't find the second transaction, but a scan with gap limit 5 will.
    // The last active indice won't be updated in the first case but will in the second one.
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 5, 1).await?;
+    let (graph_update, active_indices) = env
+        .client
+        .scan_txs_with_keychains(
+            keychains.clone(),
+            vec![].into_iter(),
+            vec![].into_iter(),
+            4,
+            1,
+        )
+        .await?;
    let txs: HashSet<_> = graph_update.full_txs().map(|tx| tx.txid).collect();
    assert_eq!(txs.len(), 1);
    assert!(txs.contains(&txid_4th_addr));
    assert_eq!(active_indices[&0], 3);
-    let (graph_update, active_indices) = client.full_scan(keychains, 6, 1).await?;
+    let (graph_update, active_indices) = env
+        .client
+        .scan_txs_with_keychains(keychains, vec![].into_iter(), vec![].into_iter(), 5, 1)
+        .await?;
    let txs: HashSet<_> = graph_update.full_txs().map(|tx| tx.txid).collect();
    assert_eq!(txs.len(), 2);
    assert!(txs.contains(&txid_4th_addr) && txs.contains(&txid_last_addr));
--- a/crates/esplora/tests/blocking_ext.rs
+++ b/crates/esplora/tests/blocking_ext.rs
@@ -1,37 +1,68 @@
-use bdk_chain::local_chain::LocalChain;
-use bdk_chain::BlockId;
 use bdk_esplora::EsploraExt;
-use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use esplora_client::{self, Builder};
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use electrsd::bitcoind::{self, anyhow, BitcoinD};
+use electrsd::{Conf, ElectrsD};
+use esplora_client::{self, BlockingClient, Builder};
+use std::collections::{BTreeMap, HashSet};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;

-use bdk_chain::bitcoin::{Address, Amount, Txid};
-use bdk_testenv::TestEnv;
+use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};

-macro_rules! h {
-    ($index:literal) => {{
-        bdk_chain::bitcoin::hashes::Hash::hash($index.as_bytes())
-    }};
+struct TestEnv {
+    bitcoind: BitcoinD,
+    #[allow(dead_code)]
+    electrsd: ElectrsD,
+    client: BlockingClient,
 }

-macro_rules! local_chain {
-    [ $(($height:expr, $block_hash:expr)), * ] => {{
-        #[allow(unused_mut)]
-        bdk_chain::local_chain::LocalChain::from_blocks([$(($height, $block_hash).into()),*].into_iter().collect())
-            .expect("chain must have genesis block")
-    }};
+impl TestEnv {
+    fn new() -> Result<Self, anyhow::Error> {
+        let bitcoind_exe =
+            bitcoind::downloaded_exe_path().expect("bitcoind version feature must be enabled");
+        let bitcoind = BitcoinD::new(bitcoind_exe).unwrap();
+
+        let mut electrs_conf = Conf::default();
+        electrs_conf.http_enabled = true;
+        let electrs_exe =
+            electrsd::downloaded_exe_path().expect("electrs version feature must be enabled");
+        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)?;
+
+        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
+        let client = Builder::new(base_url.as_str()).build_blocking()?;
+
+        Ok(Self {
+            bitcoind,
+            electrsd,
+            client,
+        })
+    }
+
+    fn mine_blocks(
+        &self,
+        count: usize,
+        address: Option<Address>,
+    ) -> anyhow::Result<Vec<BlockHash>> {
+        let coinbase_address = match address {
+            Some(address) => address,
+            None => self
+                .bitcoind
+                .client
+                .get_new_address(None, None)?
+                .assume_checked(),
+        };
+        let block_hashes = self
+            .bitcoind
+            .client
+            .generate_to_address(count as _, &coinbase_address)?;
+        Ok(block_hashes)
+    }
 }

 #[test]
 pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    let env = TestEnv::new()?;
-    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-    let client = Builder::new(base_url.as_str()).build_blocking();
-
    let receive_address0 =
        Address::from_str("bcrt1qc6fweuf4xjvz4x3gx3t9e0fh4hvqyu2qw4wvxm")?.assume_checked();
    let receive_address1 =
@@ -64,39 +95,17 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().unwrap() < 102 {
+    while env.client.get_height().unwrap() < 102 {
        sleep(Duration::from_millis(10))
    }

-    let graph_update = client.sync(
+    let graph_update = env.client.scan_txs(
        misc_spks.into_iter(),
        vec![].into_iter(),
        vec![].into_iter(),
        1,
    )?;

-    // Check to see if we have the floating txouts available from our two created transactions'
-    // previous outputs in order to calculate transaction fees.
-    for tx in graph_update.full_txs() {
-        // Retrieve the calculated fee from `TxGraph`, which will panic if we do not have the
-        // floating txouts available from the transactions' previous outputs.
-        let fee = graph_update.calculate_fee(&tx.tx).expect("Fee must exist");
-
-        // Retrieve the fee in the transaction data from `bitcoind`.
-        let tx_fee = env
-            .bitcoind
-            .client
-            .get_transaction(&tx.txid, None)
-            .expect("Tx must exist")
-            .fee
-            .expect("Fee must exist")
-            .abs()
-            .to_sat() as u64;
-
-        // Check that the calculated fee matches the fee from the transaction data.
-        assert_eq!(fee, tx_fee);
-    }
-
    let mut graph_update_txids: Vec<Txid> = graph_update.full_txs().map(|tx| tx.txid).collect();
    graph_update_txids.sort();
    let mut expected_txids = vec![txid1, txid2];
@@ -106,12 +115,10 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    Ok(())
 }

-/// Test the bounds of the address scan depending on the `stop_gap`.
+/// Test the bounds of the address scan depending on the gap limit.
 #[test]
-pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
+pub fn test_update_tx_graph_gap_limit() -> anyhow::Result<()> {
    let env = TestEnv::new()?;
-    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-    let client = Builder::new(base_url.as_str()).build_blocking();
    let _block_hashes = env.mine_blocks(101, None)?;

    // Now let's test the gap limit. First of all get a chain of 10 addresses.
@@ -151,16 +158,28 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().unwrap() < 103 {
+    while env.client.get_height().unwrap() < 103 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with a stop_gap of 3 won't find the transaction, but a scan with a gap limit of 4
+    // A scan with a gap limit of 2 won't find the transaction, but a scan with a gap limit of 3
    // will.
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 3, 1)?;
+    let (graph_update, active_indices) = env.client.scan_txs_with_keychains(
+        keychains.clone(),
+        vec![].into_iter(),
+        vec![].into_iter(),
+        2,
+        1,
+    )?;
    assert!(graph_update.full_txs().next().is_none());
    assert!(active_indices.is_empty());
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 4, 1)?;
+    let (graph_update, active_indices) = env.client.scan_txs_with_keychains(
+        keychains.clone(),
+        vec![].into_iter(),
+        vec![].into_iter(),
+        3,
+        1,
+    )?;
    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
    assert_eq!(active_indices[&0], 3);

@@ -176,18 +195,30 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().unwrap() < 104 {
+    while env.client.get_height().unwrap() < 104 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with gap limit 5 won't find the second transaction, but a scan with gap limit 6 will.
+    // A scan with gap limit 4 won't find the second transaction, but a scan with gap limit 5 will.
    // The last active indice won't be updated in the first case but will in the second one.
-    let (graph_update, active_indices) = client.full_scan(keychains.clone(), 5, 1)?;
+    let (graph_update, active_indices) = env.client.scan_txs_with_keychains(
+        keychains.clone(),
+        vec![].into_iter(),
+        vec![].into_iter(),
+        4,
+        1,
+    )?;
    let txs: HashSet<_> = graph_update.full_txs().map(|tx| tx.txid).collect();
    assert_eq!(txs.len(), 1);
    assert!(txs.contains(&txid_4th_addr));
    assert_eq!(active_indices[&0], 3);
-    let (graph_update, active_indices) = client.full_scan(keychains, 6, 1)?;
+    let (graph_update, active_indices) = env.client.scan_txs_with_keychains(
+        keychains,
+        vec![].into_iter(),
+        vec![].into_iter(),
+        5,
+        1,
+    )?;
    let txs: HashSet<_> = graph_update.full_txs().map(|tx| tx.txid).collect();
    assert_eq!(txs.len(), 2);
    assert!(txs.contains(&txid_4th_addr) && txs.contains(&txid_last_addr));
@@ -195,181 +226,3 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {

    Ok(())
 }
-
-#[test]
-fn update_local_chain() -> anyhow::Result<()> {
-    const TIP_HEIGHT: u32 = 50;
-
-    let env = TestEnv::new()?;
-    let blocks = {
-        let bitcoind_client = &env.bitcoind.client;
-        assert_eq!(bitcoind_client.get_block_count()?, 1);
-        [
-            (0, bitcoind_client.get_block_hash(0)?),
-            (1, bitcoind_client.get_block_hash(1)?),
-        ]
-        .into_iter()
-        .chain((2..).zip(env.mine_blocks((TIP_HEIGHT - 1) as usize, None)?))
-        .collect::<BTreeMap<_, _>>()
-    };
-    // so new blocks can be seen by Electrs
-    let env = env.reset_electrsd()?;
-    let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-    let client = Builder::new(base_url.as_str()).build_blocking();
-
-    struct TestCase {
-        name: &'static str,
-        chain: LocalChain,
-        request_heights: &'static [u32],
-        exp_update_heights: &'static [u32],
-    }
-
-    let test_cases = [
-        TestCase {
-            name: "request_later_blocks",
-            chain: local_chain![(0, blocks[&0]), (21, blocks[&21])],
-            request_heights: &[22, 25, 28],
-            exp_update_heights: &[21, 22, 25, 28],
-        },
-        TestCase {
-            name: "request_prev_blocks",
-            chain: local_chain![(0, blocks[&0]), (1, blocks[&1]), (5, blocks[&5])],
-            request_heights: &[4],
-            exp_update_heights: &[4, 5],
-        },
-        TestCase {
-            name: "request_prev_blocks_2",
-            chain: local_chain![(0, blocks[&0]), (1, blocks[&1]), (10, blocks[&10])],
-            request_heights: &[4, 6],
-            exp_update_heights: &[4, 6, 10],
-        },
-        TestCase {
-            name: "request_later_and_prev_blocks",
-            chain: local_chain![(0, blocks[&0]), (7, blocks[&7]), (11, blocks[&11])],
-            request_heights: &[8, 9, 15],
-            exp_update_heights: &[8, 9, 11, 15],
-        },
-        TestCase {
-            name: "request_tip_only",
-            chain: local_chain![(0, blocks[&0]), (5, blocks[&5]), (49, blocks[&49])],
-            request_heights: &[TIP_HEIGHT],
-            exp_update_heights: &[49],
-        },
-        TestCase {
-            name: "request_nothing",
-            chain: local_chain![(0, blocks[&0]), (13, blocks[&13]), (23, blocks[&23])],
-            request_heights: &[],
-            exp_update_heights: &[23],
-        },
-        TestCase {
-            name: "request_nothing_during_reorg",
-            chain: local_chain![(0, blocks[&0]), (13, blocks[&13]), (23, h!("23"))],
-            request_heights: &[],
-            exp_update_heights: &[13, 23],
-        },
-        TestCase {
-            name: "request_nothing_during_reorg_2",
-            chain: local_chain![
-                (0, blocks[&0]),
-                (21, blocks[&21]),
-                (22, h!("22")),
-                (23, h!("23"))
-            ],
-            request_heights: &[],
-            exp_update_heights: &[21, 22, 23],
-        },
-        TestCase {
-            name: "request_prev_blocks_during_reorg",
-            chain: local_chain![
-                (0, blocks[&0]),
-                (21, blocks[&21]),
-                (22, h!("22")),
-                (23, h!("23"))
-            ],
-            request_heights: &[17, 20],
-            exp_update_heights: &[17, 20, 21, 22, 23],
-        },
-        TestCase {
-            name: "request_later_blocks_during_reorg",
-            chain: local_chain![
-                (0, blocks[&0]),
-                (9, blocks[&9]),
-                (22, h!("22")),
-                (23, h!("23"))
-            ],
-            request_heights: &[25, 27],
-            exp_update_heights: &[9, 22, 23, 25, 27],
-        },
-        TestCase {
-            name: "request_later_blocks_during_reorg_2",
-            chain: local_chain![(0, blocks[&0]), (9, h!("9"))],
-            request_heights: &[10],
-            exp_update_heights: &[0, 9, 10],
-        },
-        TestCase {
-            name: "request_later_and_prev_blocks_during_reorg",
-            chain: local_chain![(0, blocks[&0]), (1, blocks[&1]), (9, h!("9"))],
-            request_heights: &[8, 11],
-            exp_update_heights: &[1, 8, 9, 11],
-        },
-    ];
-
-    for (i, t) in test_cases.into_iter().enumerate() {
-        println!("Case {}: {}", i, t.name);
-        let mut chain = t.chain;
-
-        let update = client
-            .update_local_chain(chain.tip(), t.request_heights.iter().copied())
-            .map_err(|err| {
-                anyhow::format_err!("[{}:{}] `update_local_chain` failed: {}", i, t.name, err)
-            })?;
-
-        let update_blocks = update
-            .tip
-            .iter()
-            .map(|cp| cp.block_id())
-            .collect::<BTreeSet<_>>();
-
-        let exp_update_blocks = t
-            .exp_update_heights
-            .iter()
-            .map(|&height| {
-                let hash = blocks[&height];
-                BlockId { height, hash }
-            })
-            .chain(
-                // Electrs Esplora `get_block` call fetches 10 blocks which is included in the
-                // update
-                blocks
-                    .range(TIP_HEIGHT - 9..)
-                    .map(|(&height, &hash)| BlockId { height, hash }),
-            )
-            .collect::<BTreeSet<_>>();
-
-        assert_eq!(
-            update_blocks, exp_update_blocks,
-            "[{}:{}] unexpected update",
-            i, t.name
-        );
-
-        let _ = chain
-            .apply_update(update)
-            .unwrap_or_else(|err| panic!("[{}:{}] update failed to apply: {}", i, t.name, err));
-
-        // all requested heights must exist in the final chain
-        for height in t.request_heights {
-            let exp_blockhash = blocks.get(height).expect("block must exist in bitcoind");
-            assert_eq!(
-                chain.get(*height).map(|cp| cp.hash()),
-                Some(*exp_blockhash),
-                "[{}:{}] block {}:{} must exist in final chain",
-                i,
-                t.name,
-                height,
-                exp_blockhash
-            );
-        }
-    }
-
-    Ok(())
-}
--- a/crates/file_store/Cargo.toml
+++ b/crates/file_store/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_file_store"
-version = "0.9.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -11,7 +11,7 @@ authors = ["Bitcoin Dev Kit Developers"]
 readme = "README.md"

 [dependencies]
-bdk_chain = { path = "../chain", version = "0.12.0", features = [ "serde", "miniscript" ] }
+bdk_chain = { path = "../chain", version = "0.6.0", features = [ "serde", "miniscript" ] }
 bincode = { version = "1" }
 serde = { version = "1", features = ["derive"] }

--- a/crates/file_store/src/entry_iter.rs
+++ b/crates/file_store/src/entry_iter.rs
@@ -1,7 +1,7 @@
 use bincode::Options;
 use std::{
    fs::File,
-    io::{self, BufReader, Seek},
+    io::{self, Seek},
    marker::PhantomData,
 };

@@ -14,9 +14,8 @@ use crate::bincode_options;
 ///
 /// [`next`]: Self::next
 pub struct EntryIter<'t, T> {
-    /// Buffered reader around the file
-    db_file: BufReader<&'t mut File>,
-    finished: bool,
+    db_file: Option<&'t mut File>,
+
    /// The file position for the first read of `db_file`.
    start_pos: Option<u64>,
    types: PhantomData<T>,
@@ -25,9 +24,8 @@ pub struct EntryIter<'t, T> {
 impl<'t, T> EntryIter<'t, T> {
    pub fn new(start_pos: u64, db_file: &'t mut File) -> Self {
        Self {
-            db_file: BufReader::new(db_file),
+            db_file: Some(db_file),
            start_pos: Some(start_pos),
-            finished: false,
            types: PhantomData,
        }
    }
@@ -40,44 +38,44 @@ where
    type Item = Result<T, IterError>;

    fn next(&mut self) -> Option<Self::Item> {
-        if self.finished {
-            return None;
-        }
-        (|| {
-            if let Some(start) = self.start_pos.take() {
-                self.db_file.seek(io::SeekFrom::Start(start))?;
-            }
+        // closure which reads a single entry starting from `self.pos`
+        let read_one = |f: &mut File, start_pos: Option<u64>| -> Result<Option<T>, IterError> {
+            let pos = match start_pos {
+                Some(pos) => f.seek(io::SeekFrom::Start(pos))?,
+                None => f.stream_position()?,
+            };

-            let pos_before_read = self.db_file.stream_position()?;
-            match bincode_options().deserialize_from(&mut self.db_file) {
-                Ok(changeset) => Ok(Some(changeset)),
+            match bincode_options().deserialize_from(&*f) {
+                Ok(changeset) => {
+                    f.stream_position()?;
+                    Ok(Some(changeset))
+                }
                Err(e) => {
-                    self.finished = true;
-                    let pos_after_read = self.db_file.stream_position()?;
-                    // allow unexpected EOF if 0 bytes were read
                    if let bincode::ErrorKind::Io(inner) = &*e {
-                        if inner.kind() == io::ErrorKind::UnexpectedEof
-                            && pos_after_read == pos_before_read
-                        {
-                            return Ok(None);
+                        if inner.kind() == io::ErrorKind::UnexpectedEof {
+                            let eof = f.seek(io::SeekFrom::End(0))?;
+                            if pos == eof {
+                                return Ok(None);
+                            }
                        }
                    }
-                    self.db_file.seek(io::SeekFrom::Start(pos_before_read))?;
+                    f.seek(io::SeekFrom::Start(pos))?;
                    Err(IterError::Bincode(*e))
                }
            }
-        })()
-        .transpose()
+        };
+
+        let result = read_one(self.db_file.as_mut()?, self.start_pos.take());
+        if result.is_err() {
+            self.db_file = None;
+        }
+        result.transpose()
    }
 }

-impl<'t, T> Drop for EntryIter<'t, T> {
-    fn drop(&mut self) {
-        // This syncs the underlying file's offset with the buffer's position. This way, we
-        // maintain the correct position to start the next read/write.
-        if let Ok(pos) = self.db_file.stream_position() {
-            let _ = self.db_file.get_mut().seek(io::SeekFrom::Start(pos));
-        }
+impl From<io::Error> for IterError {
+    fn from(value: io::Error) -> Self {
+        IterError::Io(value)
    }
 }

@@ -99,10 +97,4 @@ impl core::fmt::Display for IterError {
    }
 }

-impl From<io::Error> for IterError {
-    fn from(value: io::Error) -> Self {
-        IterError::Io(value)
-    }
-}
-
 impl std::error::Error for IterError {}
--- a/crates/file_store/src/lib.rs
+++ b/crates/file_store/src/lib.rs
@@ -13,14 +13,14 @@ pub(crate) fn bincode_options() -> impl bincode::Options {

 /// Error that occurs due to problems encountered with the file.
 #[derive(Debug)]
-pub enum FileError {
+pub enum FileError<'a> {
    /// IO error, this may mean that the file is too short.
    Io(io::Error),
    /// Magic bytes do not match what is expected.
-    InvalidMagicBytes { got: Vec<u8>, expected: Vec<u8> },
+    InvalidMagicBytes { got: Vec<u8>, expected: &'a [u8] },
 }

-impl core::fmt::Display for FileError {
+impl<'a> core::fmt::Display for FileError<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Io(e) => write!(f, "io error trying to read file: {}", e),
@@ -33,10 +33,10 @@ impl core::fmt::Display for FileError {
    }
 }

-impl From<io::Error> for FileError {
+impl<'a> From<io::Error> for FileError<'a> {
    fn from(value: io::Error) -> Self {
        Self::Io(value)
    }
 }

-impl std::error::Error for FileError {}
+impl<'a> std::error::Error for FileError<'a> {}
--- a/crates/file_store/src/store.rs
+++ b/crates/file_store/src/store.rs
@@ -15,13 +15,13 @@ use crate::{bincode_options, EntryIter, FileError, IterError};
 ///
 /// The changesets are the results of altering a tracker implementation (`T`).
 #[derive(Debug)]
-pub struct Store<C> {
-    magic_len: usize,
+pub struct Store<'a, C> {
+    magic: &'a [u8],
    db_file: File,
    marker: PhantomData<C>,
 }

-impl<C> PersistBackend<C> for Store<C>
+impl<'a, C> PersistBackend<C> for Store<'a, C>
 where
    C: Append + serde::Serialize + serde::de::DeserializeOwned,
 {
@@ -38,7 +38,7 @@ where
    }
 }

-impl<C> Store<C>
+impl<'a, C> Store<'a, C>
 where
    C: Append + serde::Serialize + serde::de::DeserializeOwned,
 {
@@ -48,7 +48,7 @@ where
    /// the `Store` in the future with [`open`].
    ///
    /// [`open`]: Store::open
-    pub fn create_new<P>(magic: &[u8], file_path: P) -> Result<Self, FileError>
+    pub fn create_new<P>(magic: &'a [u8], file_path: P) -> Result<Self, FileError>
    where
        P: AsRef<Path>,
    {
@@ -64,11 +64,10 @@ where
            .create(true)
            .read(true)
            .write(true)
-            .truncate(true)
            .open(file_path)?;
        f.write_all(magic)?;
        Ok(Self {
-            magic_len: magic.len(),
+            magic,
            db_file: f,
            marker: Default::default(),
        })
@@ -84,7 +83,7 @@ where
    /// [`FileError::InvalidMagicBytes`] error variant will be returned.
    ///
    /// [`create_new`]: Store::create_new
-    pub fn open<P>(magic: &[u8], file_path: P) -> Result<Self, FileError>
+    pub fn open<P>(magic: &'a [u8], file_path: P) -> Result<Self, FileError>
    where
        P: AsRef<Path>,
    {
@@ -95,24 +94,24 @@ where
        if magic_buf != magic {
            return Err(FileError::InvalidMagicBytes {
                got: magic_buf,
-                expected: magic.to_vec(),
+                expected: magic,
            });
        }

        Ok(Self {
-            magic_len: magic.len(),
+            magic,
            db_file: f,
            marker: Default::default(),
        })
    }

-    /// Attempt to open existing [`Store`] file; create it if the file is non-existent.
+    /// Attempt to open existing [`Store`] file; create it if the file is non-existant.
    ///
    /// Internally, this calls either [`open`] or [`create_new`].
    ///
    /// [`open`]: Store::open
    /// [`create_new`]: Store::create_new
-    pub fn open_or_create_new<P>(magic: &[u8], file_path: P) -> Result<Self, FileError>
+    pub fn open_or_create_new<P>(magic: &'a [u8], file_path: P) -> Result<Self, FileError>
    where
        P: AsRef<Path>,
    {
@@ -133,14 +132,14 @@ where
    /// always iterate over all entries until `None` is returned if you want your next write to go
    /// at the end; otherwise, you will write over existing entries.
    pub fn iter_changesets(&mut self) -> EntryIter<C> {
-        EntryIter::new(self.magic_len as u64, &mut self.db_file)
+        EntryIter::new(self.magic.len() as u64, &mut self.db_file)
    }

    /// Loads all the changesets that have been stored as one giant changeset.
    ///
-    /// This function returns the aggregate changeset, or `None` if nothing was persisted.
-    /// If reading or deserializing any of the entries fails, an error is returned that
-    /// consists of all those it was able to read.
+    /// This function returns a tuple of the aggregate changeset and a result that indicates
+    /// whether an error occurred while reading or deserializing one of the entries. If so the
+    /// changeset will consist of all of those it was able to read.
    ///
    /// You should usually check the error. In many applications, it may make sense to do a full
    /// wallet scan with a stop-gap after getting an error, since it is likely that one of the
@@ -220,7 +219,6 @@ mod test {

    use bincode::DefaultOptions;
    use std::{
-        collections::BTreeSet,
        io::{Read, Write},
        vec::Vec,
    };
@@ -230,7 +228,7 @@ mod test {
    const TEST_MAGIC_BYTES: [u8; TEST_MAGIC_BYTES_LEN] =
        [98, 100, 107, 102, 115, 49, 49, 49, 49, 49, 49, 49];

-    type TestChangeSet = BTreeSet<String>;
+    type TestChangeSet = Vec<String>;

    #[derive(Debug)]
    struct TestTracker;
@@ -255,7 +253,7 @@ mod test {
    fn open_or_create_new() {
        let temp_dir = tempfile::tempdir().unwrap();
        let file_path = temp_dir.path().join("db_file");
-        let changeset = BTreeSet::from(["hello".to_string(), "world".to_string()]);
+        let changeset = vec!["hello".to_string(), "world".to_string()];

        {
            let mut db = Store::<TestChangeSet>::open_or_create_new(&TEST_MAGIC_BYTES, &file_path)
@@ -306,7 +304,7 @@ mod test {
        let mut data = [255_u8; 2000];
        data[..TEST_MAGIC_BYTES_LEN].copy_from_slice(&TEST_MAGIC_BYTES);

-        let changeset = TestChangeSet::from(["one".into(), "two".into(), "three!".into()]);
+        let changeset = vec!["one".into(), "two".into(), "three!".into()];

        let mut file = NamedTempFile::new().unwrap();
        file.write_all(&data).expect("should write");
@@ -342,119 +340,4 @@ mod test {

        assert_eq!(got_bytes, expected_bytes);
    }
-
-    #[test]
-    fn last_write_is_short() {
-        let temp_dir = tempfile::tempdir().unwrap();
-
-        let changesets = [
-            TestChangeSet::from(["1".into()]),
-            TestChangeSet::from(["2".into(), "3".into()]),
-            TestChangeSet::from(["4".into(), "5".into(), "6".into()]),
-        ];
-        let last_changeset = TestChangeSet::from(["7".into(), "8".into(), "9".into()]);
-        let last_changeset_bytes = bincode_options().serialize(&last_changeset).unwrap();
-
-        for short_write_len in 1..last_changeset_bytes.len() - 1 {
-            let file_path = temp_dir.path().join(format!("{}.dat", short_write_len));
-            println!("Test file: {:?}", file_path);
-
-            // simulate creating a file, writing data where the last write is incomplete
-            {
-                let mut db =
-                    Store::<TestChangeSet>::create_new(&TEST_MAGIC_BYTES, &file_path).unwrap();
-                for changeset in &changesets {
-                    db.append_changeset(changeset).unwrap();
-                }
-                // this is the incomplete write
-                db.db_file
-                    .write_all(&last_changeset_bytes[..short_write_len])
-                    .unwrap();
-            }
-
-            // load file again and aggregate changesets
-            // write the last changeset again (this time it succeeds)
-            {
-                let mut db = Store::<TestChangeSet>::open(&TEST_MAGIC_BYTES, &file_path).unwrap();
-                let err = db
-                    .aggregate_changesets()
-                    .expect_err("should return error as last read is short");
-                assert_eq!(
-                    err.changeset,
-                    changesets.iter().cloned().reduce(|mut acc, cs| {
-                        Append::append(&mut acc, cs);
-                        acc
-                    }),
-                    "should recover all changesets that are written in full",
-                );
-                db.db_file.write_all(&last_changeset_bytes).unwrap();
-            }
-
-            // load file again - this time we should successfully aggregate all changesets
-            {
-                let mut db = Store::<TestChangeSet>::open(&TEST_MAGIC_BYTES, &file_path).unwrap();
-                let aggregated_changesets = db
-                    .aggregate_changesets()
-                    .expect("aggregating all changesets should succeed");
-                assert_eq!(
-                    aggregated_changesets,
-                    changesets
-                        .iter()
-                        .cloned()
-                        .chain(core::iter::once(last_changeset.clone()))
-                        .reduce(|mut acc, cs| {
-                            Append::append(&mut acc, cs);
-                            acc
-                        }),
-                    "should recover all changesets",
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn write_after_short_read() {
-        let temp_dir = tempfile::tempdir().unwrap();
-
-        let changesets = (0..20)
-            .map(|n| TestChangeSet::from([format!("{}", n)]))
-            .collect::<Vec<_>>();
-        let last_changeset = TestChangeSet::from(["last".into()]);
-
-        for read_count in 0..changesets.len() {
-            let file_path = temp_dir.path().join(format!("{}.dat", read_count));
-            println!("Test file: {:?}", file_path);
-
-            // First, we create the file with all the changesets!
-            let mut db = Store::<TestChangeSet>::create_new(&TEST_MAGIC_BYTES, &file_path).unwrap();
-            for changeset in &changesets {
-                db.append_changeset(changeset).unwrap();
-            }
-            drop(db);
-
-            // We re-open the file and read `read_count` number of changesets.
-            let mut db = Store::<TestChangeSet>::open(&TEST_MAGIC_BYTES, &file_path).unwrap();
-            let mut exp_aggregation = db
-                .iter_changesets()
-                .take(read_count)
-                .map(|r| r.expect("must read valid changeset"))
-                .fold(TestChangeSet::default(), |mut acc, v| {
-                    Append::append(&mut acc, v);
-                    acc
-                });
-            // We write after a short read.
-            db.write_changes(&last_changeset)
-                .expect("last write must succeed");
-            Append::append(&mut exp_aggregation, last_changeset.clone());
-            drop(db);
-
-            // We open the file again and check whether aggregate changeset is expected.
-            let aggregation = Store::<TestChangeSet>::open(&TEST_MAGIC_BYTES, &file_path)
-                .unwrap()
-                .aggregate_changesets()
-                .expect("must aggregate changesets")
-                .unwrap_or_default();
-            assert_eq!(aggregation, exp_aggregation);
-        }
-    }
 }
--- a/crates/hwi/Cargo.toml
+++ b/crates/hwi/Cargo.toml
@@ -1,13 +0,0 @@
-[package]
-name = "bdk_hwi"
-version = "0.2.0"
-edition = "2021"
-homepage = "https://bitcoindevkit.org"
-repository = "https://github.com/bitcoindevkit/bdk"
-description = "Utilities to use bdk with hardware wallets"
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-
-[dependencies]
-bdk = { path = "../bdk" }
-hwi = { version = "0.8.0", features = [ "miniscript"] }
--- a/crates/hwi/src/lib.rs
+++ b/crates/hwi/src/lib.rs
@@ -1,42 +0,0 @@
-//! HWI Signer
-//!
-//! This crate contains HWISigner, an implementation of a [`TransactionSigner`] to be
-//! used with hardware wallets.
-//! ```no_run
-//! # use bdk::bitcoin::Network;
-//! # use bdk::signer::SignerOrdering;
-//! # use bdk_hwi::HWISigner;
-//! # use bdk::wallet::AddressIndex::New;
-//! # use bdk::{KeychainKind, SignOptions, Wallet};
-//! # use hwi::HWIClient;
-//! # use std::sync::Arc;
-//! #
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! 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, Network::Testnet.into())?;
-//!
-//! # let mut wallet = Wallet::new_no_persist(
-//! #     "",
-//! #     None,
-//! #     Network::Testnet,
-//! # )?;
-//! #
-//! // Adding the hardware signer to the BDK wallet
-//! wallet.add_signer(
-//!     KeychainKind::External,
-//!     SignerOrdering(200),
-//!     Arc::new(custom_signer),
-//! );
-//!
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! [`TransactionSigner`]: bdk::wallet::signer::TransactionSigner
-
-mod signer;
-pub use signer::*;
--- a/crates/hwi/src/signer.rs
+++ b/crates/hwi/src/signer.rs
@@ -1,94 +0,0 @@
-use bdk::bitcoin::bip32::Fingerprint;
-use bdk::bitcoin::secp256k1::{All, Secp256k1};
-use bdk::bitcoin::Psbt;
-
-use hwi::error::Error;
-use hwi::types::{HWIChain, HWIDevice};
-use hwi::HWIClient;
-
-use bdk::signer::{SignerCommon, SignerError, SignerId, TransactionSigner};
-
-#[derive(Debug)]
-/// Custom signer for Hardware Wallets
-///
-/// This ignores `sign_options` and leaves the decisions up to the hardware wallet.
-pub struct HWISigner {
-    fingerprint: Fingerprint,
-    client: HWIClient,
-}
-
-impl HWISigner {
-    /// Create a instance from the specified device and chain
-    pub fn from_device(device: &HWIDevice, chain: HWIChain) -> Result<HWISigner, Error> {
-        let client = HWIClient::get_client(device, false, chain)?;
-        Ok(HWISigner {
-            fingerprint: device.fingerprint,
-            client,
-        })
-    }
-}
-
-impl SignerCommon for HWISigner {
-    fn id(&self, _secp: &Secp256k1<All>) -> SignerId {
-        SignerId::Fingerprint(self.fingerprint)
-    }
-}
-
-impl TransactionSigner for HWISigner {
-    fn sign_transaction(
-        &self,
-        psbt: &mut Psbt,
-        _sign_options: &bdk::SignOptions,
-        _secp: &Secp256k1<All>,
-    ) -> Result<(), SignerError> {
-        psbt.combine(
-            self.client
-                .sign_tx(psbt)
-                .map_err(|e| {
-                    SignerError::External(format!("While signing with hardware wallet: {}", e))
-                })?
-                .psbt,
-        )
-        .expect("Failed to combine HW signed psbt with passed PSBT");
-        Ok(())
-    }
-}
-
-// TODO: re-enable this once we have the `get_funded_wallet` test util
-// #[cfg(test)]
-// mod tests {
-//     #[test]
-//     fn test_hardware_signer() {
-//         use std::sync::Arc;
-//
-//         use bdk::tests::get_funded_wallet;
-//         use bdk::signer::SignerOrdering;
-//         use bdk::bitcoin::Network;
-//         use crate::HWISigner;
-//         use hwi::HWIClient;
-//
-//         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, Network::Regtest.into()).unwrap();
-//         let descriptors = client.get_descriptors::<String>(None).unwrap();
-//         let custom_signer = HWISigner::from_device(&device, Network::Regtest.into()).unwrap();
-//
-//         let (mut wallet, _) = get_funded_wallet(&descriptors.internal[0]);
-//         wallet.add_signer(
-//             bdk::KeychainKind::External,
-//             SignerOrdering(200),
-//             Arc::new(custom_signer),
-//         );
-//
-//         let addr = wallet.get_address(bdk::wallet::AddressIndex::LastUnused);
-//         let mut builder = wallet.build_tx();
-//         builder.drain_to(addr.script_pubkey()).drain_wallet();
-//         let (mut psbt, _) = builder.finish().unwrap();
-//
-//         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-//         assert!(finalized);
-//     }
-// }
--- a/crates/testenv/Cargo.toml
+++ b/crates/testenv/Cargo.toml
@@ -1,24 +0,0 @@
-[package]
-name = "bdk_testenv"
-version = "0.2.0"
-edition = "2021"
-rust-version = "1.63"
-homepage = "https://bitcoindevkit.org"
-repository = "https://github.com/bitcoindevkit/bdk"
-documentation = "https://docs.rs/bdk_testenv"
-description = "Testing framework for BDK chain sources."
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bitcoincore-rpc = { version = "0.18" }
-bdk_chain = { path = "../chain", version = "0.12", default-features = false }
-electrsd = { version= "0.27.1", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
-anyhow = { version = "1" }
-
-[features]
-default = ["std"]
-std = ["bdk_chain/std"]
-serde = ["bdk_chain/serde"]
--- a/crates/testenv/README.md
+++ b/crates/testenv/README.md
@@ -1,6 +0,0 @@
-# BDK TestEnv
-
-This crate sets up a regtest environment with a single [`bitcoind`] node
-connected to an [`electrs`] instance. This framework provides the infrastructure
-for testing chain source crates, e.g., [`bdk_chain`], [`bdk_electrum`],
-[`bdk_esplora`], etc.
--- a/crates/testenv/src/lib.rs
+++ b/crates/testenv/src/lib.rs
@@ -1,278 +0,0 @@
-use bdk_chain::bitcoin::{
-    address::NetworkChecked, block::Header, hash_types::TxMerkleNode, hashes::Hash,
-    secp256k1::rand::random, transaction, Address, Amount, Block, BlockHash, CompactTarget,
-    ScriptBuf, ScriptHash, Transaction, TxIn, TxOut, Txid,
-};
-use bitcoincore_rpc::{
-    bitcoincore_rpc_json::{GetBlockTemplateModes, GetBlockTemplateRules},
-    RpcApi,
-};
-use electrsd::electrum_client::ElectrumApi;
-use std::time::Duration;
-
-/// Struct for running a regtest environment with a single `bitcoind` node with an `electrs`
-/// instance connected to it.
-pub struct TestEnv {
-    pub bitcoind: electrsd::bitcoind::BitcoinD,
-    pub electrsd: electrsd::ElectrsD,
-}
-
-impl TestEnv {
-    /// Construct a new [`TestEnv`] instance with default configurations.
-    pub fn new() -> anyhow::Result<Self> {
-        let bitcoind = match std::env::var_os("BITCOIND_EXE") {
-            Some(bitcoind_path) => electrsd::bitcoind::BitcoinD::new(bitcoind_path),
-            None => {
-                let bitcoind_exe = electrsd::bitcoind::downloaded_exe_path()
-                    .expect(
-                "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature",
-                );
-                electrsd::bitcoind::BitcoinD::with_conf(
-                    bitcoind_exe,
-                    &electrsd::bitcoind::Conf::default(),
-                )
-            }
-        }?;
-
-        let mut electrsd_conf = electrsd::Conf::default();
-        electrsd_conf.http_enabled = true;
-        let electrsd = match std::env::var_os("ELECTRS_EXE") {
-            Some(env_electrs_exe) => {
-                electrsd::ElectrsD::with_conf(env_electrs_exe, &bitcoind, &electrsd_conf)
-            }
-            None => {
-                let electrs_exe = electrsd::downloaded_exe_path()
-                    .expect("electrs version feature must be enabled");
-                electrsd::ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf)
-            }
-        }?;
-
-        Ok(Self { bitcoind, electrsd })
-    }
-
-    /// Exposes the [`ElectrumApi`] calls from the Electrum client.
-    pub fn electrum_client(&self) -> &impl ElectrumApi {
-        &self.electrsd.client
-    }
-
-    /// Exposes the [`RpcApi`] calls from [`bitcoincore_rpc`].
-    pub fn rpc_client(&self) -> &impl RpcApi {
-        &self.bitcoind.client
-    }
-
-    // Reset `electrsd` so that new blocks can be seen.
-    pub fn reset_electrsd(mut self) -> anyhow::Result<Self> {
-        let mut electrsd_conf = electrsd::Conf::default();
-        electrsd_conf.http_enabled = true;
-        let electrsd = match std::env::var_os("ELECTRS_EXE") {
-            Some(env_electrs_exe) => {
-                electrsd::ElectrsD::with_conf(env_electrs_exe, &self.bitcoind, &electrsd_conf)
-            }
-            None => {
-                let electrs_exe = electrsd::downloaded_exe_path()
-                    .expect("electrs version feature must be enabled");
-                electrsd::ElectrsD::with_conf(electrs_exe, &self.bitcoind, &electrsd_conf)
-            }
-        }?;
-        self.electrsd = electrsd;
-        Ok(self)
-    }
-
-    /// Mine a number of blocks of a given size `count`, which may be specified to a given coinbase
-    /// `address`.
-    pub fn mine_blocks(
-        &self,
-        count: usize,
-        address: Option<Address>,
-    ) -> anyhow::Result<Vec<BlockHash>> {
-        let coinbase_address = match address {
-            Some(address) => address,
-            None => self
-                .bitcoind
-                .client
-                .get_new_address(None, None)?
-                .assume_checked(),
-        };
-        let block_hashes = self
-            .bitcoind
-            .client
-            .generate_to_address(count as _, &coinbase_address)?;
-        Ok(block_hashes)
-    }
-
-    /// Mine a block that is guaranteed to be empty even with transactions in the mempool.
-    pub fn mine_empty_block(&self) -> anyhow::Result<(usize, BlockHash)> {
-        let bt = self.bitcoind.client.get_block_template(
-            GetBlockTemplateModes::Template,
-            &[GetBlockTemplateRules::SegWit],
-            &[],
-        )?;
-
-        let txdata = vec![Transaction {
-            version: transaction::Version::ONE,
-            lock_time: bdk_chain::bitcoin::absolute::LockTime::from_height(0)?,
-            input: vec![TxIn {
-                previous_output: bdk_chain::bitcoin::OutPoint::default(),
-                script_sig: ScriptBuf::builder()
-                    .push_int(bt.height as _)
-                    // randomn number so that re-mining creates unique block
-                    .push_int(random())
-                    .into_script(),
-                sequence: bdk_chain::bitcoin::Sequence::default(),
-                witness: bdk_chain::bitcoin::Witness::new(),
-            }],
-            output: vec![TxOut {
-                value: Amount::ZERO,
-                script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()),
-            }],
-        }];
-
-        let bits: [u8; 4] = bt
-            .bits
-            .clone()
-            .try_into()
-            .expect("rpc provided us with invalid bits");
-
-        let mut block = Block {
-            header: Header {
-                version: bdk_chain::bitcoin::block::Version::default(),
-                prev_blockhash: bt.previous_block_hash,
-                merkle_root: TxMerkleNode::all_zeros(),
-                time: Ord::max(bt.min_time, std::time::UNIX_EPOCH.elapsed()?.as_secs()) as u32,
-                bits: CompactTarget::from_consensus(u32::from_be_bytes(bits)),
-                nonce: 0,
-            },
-            txdata,
-        };
-
-        block.header.merkle_root = block.compute_merkle_root().expect("must compute");
-
-        for nonce in 0..=u32::MAX {
-            block.header.nonce = nonce;
-            if block.header.target().is_met_by(block.block_hash()) {
-                break;
-            }
-        }
-
-        self.bitcoind.client.submit_block(&block)?;
-        Ok((bt.height as usize, block.block_hash()))
-    }
-
-    /// This method waits for the Electrum notification indicating that a new block has been mined.
-    pub fn wait_until_electrum_sees_block(&self) -> anyhow::Result<()> {
-        self.electrsd.client.block_headers_subscribe()?;
-        let mut delay = Duration::from_millis(64);
-
-        loop {
-            self.electrsd.trigger()?;
-            self.electrsd.client.ping()?;
-            if self.electrsd.client.block_headers_pop()?.is_some() {
-                return Ok(());
-            }
-
-            if delay.as_millis() < 512 {
-                delay = delay.mul_f32(2.0);
-            }
-            std::thread::sleep(delay);
-        }
-    }
-
-    /// Invalidate a number of blocks of a given size `count`.
-    pub fn invalidate_blocks(&self, count: usize) -> anyhow::Result<()> {
-        let mut hash = self.bitcoind.client.get_best_block_hash()?;
-        for _ in 0..count {
-            let prev_hash = self
-                .bitcoind
-                .client
-                .get_block_info(&hash)?
-                .previousblockhash;
-            self.bitcoind.client.invalidate_block(&hash)?;
-            match prev_hash {
-                Some(prev_hash) => hash = prev_hash,
-                None => break,
-            }
-        }
-        Ok(())
-    }
-
-    /// Reorg a number of blocks of a given size `count`.
-    /// Refer to [`TestEnv::mine_empty_block`] for more information.
-    pub fn reorg(&self, count: usize) -> anyhow::Result<Vec<BlockHash>> {
-        let start_height = self.bitcoind.client.get_block_count()?;
-        self.invalidate_blocks(count)?;
-
-        let res = self.mine_blocks(count, None);
-        assert_eq!(
-            self.bitcoind.client.get_block_count()?,
-            start_height,
-            "reorg should not result in height change"
-        );
-        res
-    }
-
-    /// Reorg with a number of empty blocks of a given size `count`.
-    pub fn reorg_empty_blocks(&self, count: usize) -> anyhow::Result<Vec<(usize, BlockHash)>> {
-        let start_height = self.bitcoind.client.get_block_count()?;
-        self.invalidate_blocks(count)?;
-
-        let res = (0..count)
-            .map(|_| self.mine_empty_block())
-            .collect::<Result<Vec<_>, _>>()?;
-        assert_eq!(
-            self.bitcoind.client.get_block_count()?,
-            start_height,
-            "reorg should not result in height change"
-        );
-        Ok(res)
-    }
-
-    /// Send a tx of a given `amount` to a given `address`.
-    pub fn send(&self, address: &Address<NetworkChecked>, amount: Amount) -> anyhow::Result<Txid> {
-        let txid = self
-            .bitcoind
-            .client
-            .send_to_address(address, amount, None, None, None, None, None, None)?;
-        Ok(txid)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::TestEnv;
-    use anyhow::Result;
-    use bitcoincore_rpc::RpcApi;
-
-    /// This checks that reorgs initiated by `bitcoind` is detected by our `electrsd` instance.
-    #[test]
-    fn test_reorg_is_detected_in_electrsd() -> Result<()> {
-        let env = TestEnv::new()?;
-
-        // Mine some blocks.
-        env.mine_blocks(101, None)?;
-        env.wait_until_electrum_sees_block()?;
-        let height = env.bitcoind.client.get_block_count()?;
-        let blocks = (0..=height)
-            .map(|i| env.bitcoind.client.get_block_hash(i))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        // Perform reorg on six blocks.
-        env.reorg(6)?;
-        env.wait_until_electrum_sees_block()?;
-        let reorged_height = env.bitcoind.client.get_block_count()?;
-        let reorged_blocks = (0..=height)
-            .map(|i| env.bitcoind.client.get_block_hash(i))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        assert_eq!(height, reorged_height);
-
-        // Block hashes should not be equal on the six reorged blocks.
-        for (i, (block, reorged_block)) in blocks.iter().zip(reorged_blocks.iter()).enumerate() {
-            match i <= height as usize - 6 {
-                true => assert_eq!(block, reorged_block),
-                false => assert_ne!(block, reorged_block),
-            }
-        }
-
-        Ok(())
-    }
-}
--- a/example-crates/example_bitcoind_rpc_polling/README.md
+++ b/example-crates/example_bitcoind_rpc_polling/README.md
@@ -1,68 +0,0 @@
-# Example RPC CLI
-
-### Simple Regtest Test
-
-1. Start local regtest bitcoind.
-   ```
-    mkdir -p /tmp/regtest/bitcoind
-    bitcoind -regtest -server -fallbackfee=0.0002 -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> -datadir=/tmp/regtest/bitcoind -daemon
-   ```
-2. Create a test bitcoind wallet and set bitcoind env.
-   ```
-   bitcoin-cli -datadir=/tmp/regtest/bitcoind -regtest -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> -named createwallet wallet_name="test"
-   export RPC_URL=127.0.0.1:18443
-   export RPC_USER=<your-rpc-username>
-   export RPC_PASS=<your-rpc-password>
-   ```
-3. Get test bitcoind wallet info.
-   ```
-   bitcoin-cli -rpcwallet="test" -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> -datadir=/tmp/regtest/bitcoind -regtest getwalletinfo
-   ```
-4. Get new test bitcoind wallet address.
-   ```
-   BITCOIND_ADDRESS=$(bitcoin-cli -rpcwallet="test" -datadir=/tmp/regtest/bitcoind -regtest -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> getnewaddress)
-   echo $BITCOIND_ADDRESS
-   ```
-5. Generate 101 blocks with reward to test bitcoind wallet address.
-   ```
-   bitcoin-cli -datadir=/tmp/regtest/bitcoind -regtest -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> generatetoaddress 101 $BITCOIND_ADDRESS
-   ```
-6. Verify test bitcoind wallet balance.
-   ```
-   bitcoin-cli -rpcwallet="test" -datadir=/tmp/regtest/bitcoind -regtest -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> getbalances
-   ```
-7. Set descriptor env and get address from RPC CLI wallet.
-   ```
-   export DESCRIPTOR="wpkh(tprv8ZgxMBicQKsPfK9BTf82oQkHhawtZv19CorqQKPFeaHDMA4dXYX6eWsJGNJ7VTQXWmoHdrfjCYuDijcRmNFwSKcVhswzqs4fugE8turndGc/1/*)"
-   cargo run -- --network regtest address next
-   ```
-8. Send 5 test bitcoin to RPC CLI wallet.
-   ```
-   bitcoin-cli -rpcwallet="test" -datadir=/tmp/regtest/bitcoind -regtest -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> sendtoaddress <address> 5
-   ```
-9. Sync blockchain with RPC CLI wallet.
-   ```
-   cargo run -- --network regtest sync
-   <CNTRL-C to stop syncing>
-   ```
-10. Get RPC CLI wallet unconfirmed balances.
-   ```
-   cargo run -- --network regtest balance
-   ```
-11. Generate 1 block with reward to test bitcoind wallet address.
-   ```
-   bitcoin-cli -datadir=/tmp/regtest/bitcoind -rpcuser=<your-rpc-username> -rpcpassword=<your-rpc-password> -regtest generatetoaddress 10 $BITCOIND_ADDRESS
-   ```
-12. Sync the blockchain with RPC CLI wallet.
-   ```
-   cargo run -- --network regtest sync
-   <CNTRL-C to stop syncing>
-   ```
-13. Get RPC CLI wallet confirmed balances.
-   ```
-   cargo run -- --network regtest balance
-   ```
-14. Get RPC CLI wallet transactions.
-   ```
-   cargo run -- --network regtest txout list
-   ```
--- a/example-crates/example_bitcoind_rpc_polling/src/main.rs
+++ b/example-crates/example_bitcoind_rpc_polling/src/main.rs
@@ -12,9 +12,9 @@ use bdk_bitcoind_rpc::{
    Emitter,
 };
 use bdk_chain::{
-    bitcoin::{constants::genesis_block, Block, Transaction},
+    bitcoin::{Block, Transaction},
    indexed_tx_graph, keychain,
-    local_chain::{self, LocalChain},
+    local_chain::{self, CheckPoint, LocalChain},
    ConfirmationTimeHeightAnchor, IndexedTxGraph,
 };
 use example_cli::{
@@ -42,7 +42,7 @@ type ChangeSet = (

 #[derive(Debug)]
 enum Emission {
-    Block(bdk_bitcoind_rpc::BlockEvent<Block>),
+    Block { height: u32, block: Block },
    Mempool(Vec<(Transaction, u64)>),
    Tip(u32),
 }
@@ -64,6 +64,9 @@ struct RpcArgs {
    /// Starting block height to fallback to if no point of agreement if found
    #[clap(env = "FALLBACK_HEIGHT", long, default_value = "0")]
    fallback_height: u32,
+    /// The unused-scripts lookahead will be kept at this size
+    #[clap(long, default_value = "10")]
+    lookahead: u32,
 }

 impl From<RpcArgs> for Auth {
@@ -110,22 +113,17 @@ enum RpcCommands {

 fn main() -> anyhow::Result<()> {
    let start = Instant::now();
-    let example_cli::Init {
-        args,
-        keymap,
-        index,
-        db,
-        init_changeset,
-    } = example_cli::init::<RpcCommands, RpcArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;
+
+    let (args, keymap, index, db, init_changeset) =
+        example_cli::init::<RpcCommands, RpcArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;
    println!(
        "[{:>10}s] loaded initial changeset from db",
        start.elapsed().as_secs_f32()
    );
-    let (init_chain_changeset, init_graph_changeset) = init_changeset;

    let graph = Mutex::new({
        let mut graph = IndexedTxGraph::new(index);
-        graph.apply_changeset(init_graph_changeset);
+        graph.apply_changeset(init_changeset.1);
        graph
    });
    println!(
@@ -133,16 +131,7 @@ fn main() -> anyhow::Result<()> {
        start.elapsed().as_secs_f32()
    );

-    let chain = Mutex::new(if init_chain_changeset.is_empty() {
-        let genesis_hash = genesis_block(args.network).block_hash();
-        let (chain, chain_changeset) = LocalChain::from_genesis_hash(genesis_hash);
-        let mut db = db.lock().unwrap();
-        db.stage((chain_changeset, Default::default()));
-        db.commit()?;
-        chain
-    } else {
-        LocalChain::from_changeset(init_chain_changeset)?
-    });
+    let chain = Mutex::new(LocalChain::from_changeset(init_changeset.0)?);
    println!(
        "[{:>10}s] loaded local chain from changeset",
        start.elapsed().as_secs_f32()
@@ -151,7 +140,7 @@ fn main() -> anyhow::Result<()> {
    let rpc_cmd = match args.command {
        example_cli::Commands::ChainSpecific(rpc_cmd) => rpc_cmd,
        general_cmd => {
-            return example_cli::handle_commands(
+            let res = example_cli::handle_commands(
                &graph,
                &db,
                &chain,
@@ -164,15 +153,21 @@ fn main() -> anyhow::Result<()> {
                },
                general_cmd,
            );
+            db.lock().unwrap().commit()?;
+            return res;
        }
    };

    match rpc_cmd {
        RpcCommands::Sync { rpc_args } => {
            let RpcArgs {
-                fallback_height, ..
+                fallback_height,
+                lookahead,
+                ..
            } = rpc_args;

+            graph.lock().unwrap().index.set_lookahead_for_all(lookahead);
+
            let chain_tip = chain.lock().unwrap().tip();
            let rpc_client = rpc_args.new_client()?;
            let mut emitter = Emitter::new(&rpc_client, chain_tip, fallback_height);
@@ -180,20 +175,17 @@ fn main() -> anyhow::Result<()> {
            let mut last_db_commit = Instant::now();
            let mut last_print = Instant::now();

-            while let Some(emission) = emitter.next_block()? {
-                let height = emission.block_height();
-
+            while let Some((height, block)) = emitter.next_block()? {
                let mut chain = chain.lock().unwrap();
                let mut graph = graph.lock().unwrap();
                let mut db = db.lock().unwrap();

+                let chain_update =
+                    CheckPoint::from_header(&block.header, height).into_update(false);
                let chain_changeset = chain
-                    .apply_update(local_chain::Update {
-                        tip: emission.checkpoint,
-                        introduce_older_blocks: false,
-                    })
+                    .apply_update(chain_update)
                    .expect("must always apply as we receive blocks in order from emitter");
-                let graph_changeset = graph.apply_block_relevant(&emission.block, height);
+                let graph_changeset = graph.apply_block_relevant(block, height);
                db.stage((chain_changeset, graph_changeset));

                // commit staged db changes in intervals
@@ -241,10 +233,13 @@ fn main() -> anyhow::Result<()> {
        }
        RpcCommands::Live { rpc_args } => {
            let RpcArgs {
-                fallback_height, ..
+                fallback_height,
+                lookahead,
+                ..
            } = rpc_args;
            let sigterm_flag = start_ctrlc_handler();

+            graph.lock().unwrap().index.set_lookahead_for_all(lookahead);
            let last_cp = chain.lock().unwrap().tip();

            println!(
@@ -261,8 +256,7 @@ fn main() -> anyhow::Result<()> {

                loop {
                    match emitter.next_block()? {
-                        Some(block_emission) => {
-                            let height = block_emission.block_height();
+                        Some((height, block)) => {
                            if sigterm_flag.load(Ordering::Acquire) {
                                break;
                            }
@@ -270,7 +264,7 @@ fn main() -> anyhow::Result<()> {
                                block_count = rpc_client.get_block_count()? as u32;
                                tx.send(Emission::Tip(block_count))?;
                            }
-                            tx.send(Emission::Block(block_emission))?;
+                            tx.send(Emission::Block { height, block })?;
                        }
                        None => {
                            if await_flag(&sigterm_flag, MEMPOOL_EMIT_DELAY) {
@@ -299,17 +293,13 @@ fn main() -> anyhow::Result<()> {
                let mut chain = chain.lock().unwrap();

                let changeset = match emission {
-                    Emission::Block(block_emission) => {
-                        let height = block_emission.block_height();
-                        let chain_update = local_chain::Update {
-                            tip: block_emission.checkpoint,
-                            introduce_older_blocks: false,
-                        };
+                    Emission::Block { height, block } => {
+                        let chain_update =
+                            CheckPoint::from_header(&block.header, height).into_update(false);
                        let chain_changeset = chain
                            .apply_update(chain_update)
                            .expect("must always apply as we receive blocks in order from emitter");
-                        let graph_changeset =
-                            graph.apply_block_relevant(&block_emission.block, height);
+                        let graph_changeset = graph.apply_block_relevant(block, height);
                        (chain_changeset, graph_changeset)
                    }
                    Emission::Mempool(mempool_txs) => {
--- a/example-crates/example_cli/src/lib.rs
+++ b/example-crates/example_cli/src/lib.rs
@@ -3,14 +3,12 @@ use anyhow::Context;
 use bdk_coin_select::{coin_select_bnb, CoinSelector, CoinSelectorOpt, WeightedValue};
 use bdk_file_store::Store;
 use serde::{de::DeserializeOwned, Serialize};
-use std::{cmp::Reverse, collections::BTreeMap, path::PathBuf, sync::Mutex, time::Duration};
+use std::{cmp::Reverse, collections::HashMap, path::PathBuf, sync::Mutex, time::Duration};

 use bdk_chain::{
    bitcoin::{
-        absolute, address,
-        secp256k1::Secp256k1,
-        sighash::{Prevouts, SighashCache},
-        transaction, Address, Amount, Network, Sequence, Transaction, TxIn, TxOut,
+        absolute, address, psbt::Prevouts, secp256k1::Secp256k1, sighash::SighashCache, Address,
+        Network, Sequence, Transaction, TxIn, TxOut,
    },
    indexed_tx_graph::{self, IndexedTxGraph},
    keychain::{self, KeychainTxOutIndex},
@@ -31,7 +29,7 @@ pub type KeychainChangeSet<A> = (
    local_chain::ChangeSet,
    indexed_tx_graph::ChangeSet<A, keychain::ChangeSet<Keychain>>,
 );
-pub type Database<C> = Persist<Store<C>, C>;
+pub type Database<'m, C> = Persist<Store<'m, C>, C>;

 #[derive(Parser)]
 #[clap(author, version, about, long_about = None)]
@@ -55,6 +53,7 @@ pub struct Args<CS: clap::Subcommand, S: clap::Args> {
    pub command: Commands<CS, S>,
 }

+#[allow(clippy::almost_swapped)]
 #[derive(Subcommand, Debug, Clone)]
 pub enum Commands<CS: clap::Subcommand, S: clap::Args> {
    #[clap(flatten)]
@@ -74,9 +73,7 @@ pub enum Commands<CS: clap::Subcommand, S: clap::Args> {
    },
    /// Send coins to an address.
    Send {
-        /// Amount to send in satoshis
        value: u64,
-        /// Destination address
        address: Address<address::NetworkUnchecked>,
        #[clap(short, default_value = "bnb")]
        coin_select: CoinSelectionAlgo,
@@ -138,6 +135,7 @@ impl core::fmt::Display for CoinSelectionAlgo {
    }
 }

+#[allow(clippy::almost_swapped)]
 #[derive(Subcommand, Debug, Clone)]
 pub enum AddressCmd {
    /// Get the next unused address.
@@ -146,17 +144,14 @@ pub enum AddressCmd {
    New,
    /// List all addresses
    List {
-        /// List change addresses
        #[clap(long)]
        change: bool,
    },
-    /// Get last revealed address index for each keychain.
    Index,
 }

 #[derive(Subcommand, Debug, Clone)]
 pub enum TxOutCmd {
-    /// List transaction outputs.
    List {
        /// Return only spent outputs.
        #[clap(short, long)]
@@ -190,20 +185,18 @@ impl core::fmt::Display for Keychain {
    }
 }

-pub struct CreateTxChange {
-    pub index_changeset: keychain::ChangeSet<Keychain>,
-    pub change_keychain: Keychain,
-    pub index: u32,
-}
-
+#[allow(clippy::type_complexity)]
 pub fn create_tx<A: Anchor, O: ChainOracle>(
    graph: &mut KeychainTxGraph<A>,
    chain: &O,
-    keymap: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>,
+    keymap: &HashMap<DescriptorPublicKey, DescriptorSecretKey>,
    cs_algorithm: CoinSelectionAlgo,
    address: Address,
    value: u64,
-) -> anyhow::Result<(Transaction, Option<CreateTxChange>)>
+) -> anyhow::Result<(
+    Transaction,
+    Option<(keychain::ChangeSet<Keychain>, (Keychain, u32))>,
+)>
 where
    O::Error: std::error::Error + Send + Sync + 'static,
 {
@@ -237,7 +230,7 @@ where
        .iter()
        .map(|(plan, utxo)| {
            WeightedValue::new(
-                utxo.txout.value.to_sat(),
+                utxo.txout.value,
                plan.expected_weight() as _,
                plan.witness_version().is_some(),
            )
@@ -245,7 +238,7 @@ where
        .collect();

    let mut outputs = vec![TxOut {
-        value: Amount::from_sat(value),
+        value,
        script_pubkey: address.script_pubkey(),
    }];

@@ -275,7 +268,7 @@ where
    .expect("failed to obtain change plan");

    let mut change_output = TxOut {
-        value: Amount::ZERO,
+        value: 0,
        script_pubkey: change_script,
    };

@@ -313,13 +306,13 @@ where
    let selected_txos = selection.apply_selection(&candidates).collect::<Vec<_>>();

    if let Some(drain_value) = selection_meta.drain_value {
-        change_output.value = Amount::from_sat(drain_value);
+        change_output.value = drain_value;
        // if the selection tells us to use change and the change value is sufficient, we add it as an output
        outputs.push(change_output)
    }

    let mut transaction = Transaction {
-        version: transaction::Version::TWO,
+        version: 0x02,
        // because the temporary planning module does not support timelocks, we can use the chain
        // tip as the `lock_time` for anti-fee-sniping purposes
        lock_time: absolute::LockTime::from_height(chain.get_chain_tip()?.height)
@@ -395,11 +388,7 @@ where
    }

    let change_info = if selection_meta.drain_value.is_some() {
-        Some(CreateTxChange {
-            index_changeset: changeset,
-            change_keychain: internal_keychain,
-            index: change_index,
-        })
+        Some((changeset, (internal_keychain, change_index)))
    } else {
        None
    };
@@ -407,34 +396,35 @@ where
    Ok((transaction, change_info))
 }

-// Alias the elements of `Result` of `planned_utxos`
-pub type PlannedUtxo<K, A> = (bdk_tmp_plan::Plan<K>, FullTxOut<A>);
-
+#[allow(clippy::type_complexity)]
 pub fn planned_utxos<A: Anchor, O: ChainOracle, K: Clone + bdk_tmp_plan::CanDerive>(
    graph: &KeychainTxGraph<A>,
    chain: &O,
    assets: &bdk_tmp_plan::Assets<K>,
-) -> Result<Vec<PlannedUtxo<K, A>>, O::Error> {
+) -> Result<Vec<(bdk_tmp_plan::Plan<K>, FullTxOut<A>)>, O::Error> {
    let chain_tip = chain.get_chain_tip()?;
    let outpoints = graph.index.outpoints().iter().cloned();
    graph
        .graph()
        .try_filter_chain_unspents(chain, chain_tip, outpoints)
-        .filter_map(|r| -> Option<Result<PlannedUtxo<K, A>, _>> {
-            let (k, i, full_txo) = match r {
-                Err(err) => return Some(Err(err)),
-                Ok(((k, i), full_txo)) => (k, i, full_txo),
-            };
-            let desc = graph
-                .index
-                .keychains()
-                .get(&k)
-                .expect("keychain must exist")
-                .at_derivation_index(i)
-                .expect("i can't be hardened");
-            let plan = bdk_tmp_plan::plan_satisfaction(&desc, assets)?;
-            Some(Ok((plan, full_txo)))
-        })
+        .filter_map(
+            #[allow(clippy::type_complexity)]
+            |r| -> Option<Result<(bdk_tmp_plan::Plan<K>, FullTxOut<A>), _>> {
+                let (k, i, full_txo) = match r {
+                    Err(err) => return Some(Err(err)),
+                    Ok(((k, i), full_txo)) => (k, i, full_txo),
+                };
+                let desc = graph
+                    .index
+                    .keychains()
+                    .get(&k)
+                    .expect("keychain must exist")
+                    .at_derivation_index(i)
+                    .expect("i can't be hardened");
+                let plan = bdk_tmp_plan::plan_satisfaction(&desc, assets)?;
+                Some(Ok((plan, full_txo)))
+            },
+        )
        .collect()
 }

@@ -442,7 +432,7 @@ pub fn handle_commands<CS: clap::Subcommand, S: clap::Args, A: Anchor, O: ChainO
    graph: &Mutex<KeychainTxGraph<A>>,
    db: &Mutex<Database<C>>,
    chain: &Mutex<O>,
-    keymap: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>,
+    keymap: &HashMap<DescriptorPublicKey, DescriptorSecretKey>,
    network: Network,
    broadcast: impl FnOnce(S, &Transaction) -> anyhow::Result<()>,
    cmd: Commands<CS, S>,
@@ -467,10 +457,11 @@ where

                    let ((spk_i, spk), index_changeset) = spk_chooser(index, &Keychain::External);
                    let db = &mut *db.lock().unwrap();
-                    db.stage_and_commit(C::from((
+                    db.stage(C::from((
                        local_chain::ChangeSet::default(),
                        indexed_tx_graph::ChangeSet::from(index_changeset),
-                    )))?;
+                    )));
+                    db.commit()?;
                    let addr =
                        Address::from_script(spk, network).context("failed to derive address")?;
                    println!("[address @ {}] {}", spk_i, addr);
@@ -487,14 +478,14 @@ where
                        true => Keychain::Internal,
                        false => Keychain::External,
                    };
-                    for (spk_i, spk) in index.revealed_keychain_spks(&target_keychain) {
+                    for (spk_i, spk) in index.revealed_spks_of_keychain(&target_keychain) {
                        let address = Address::from_script(spk, network)
                            .expect("should always be able to derive address");
                        println!(
                            "{:?} {} used:{}",
                            spk_i,
                            address,
-                            index.is_used(target_keychain, spk_i)
+                            index.is_used(&(target_keychain, spk_i))
                        );
                    }
                    Ok(())
@@ -604,27 +595,23 @@ where
                let (tx, change_info) =
                    create_tx(graph, chain, keymap, coin_select, address, value)?;

-                if let Some(CreateTxChange {
-                    index_changeset,
-                    change_keychain,
-                    index,
-                }) = change_info
-                {
+                if let Some((index_changeset, (change_keychain, index))) = change_info {
                    // We must first persist to disk the fact that we've got a new address from the
                    // change keychain so future scans will find the tx we're about to broadcast.
                    // If we're unable to persist this, then we don't want to broadcast.
                    {
                        let db = &mut *db.lock().unwrap();
-                        db.stage_and_commit(C::from((
+                        db.stage(C::from((
                            local_chain::ChangeSet::default(),
                            indexed_tx_graph::ChangeSet::from(index_changeset),
-                        )))?;
+                        )));
+                        db.commit()?;
                    }

                    // We don't want other callers/threads to use this address while we're using it
                    // but we also don't want to scan the tx we just created because it's not
                    // technically in the blockchain yet.
-                    graph.index.mark_used(change_keychain, index);
+                    graph.index.mark_used(&change_keychain, index);
                    (tx, Some((change_keychain, index)))
                } else {
                    (tx, None)
@@ -640,16 +627,16 @@ where
                    // We know the tx is at least unconfirmed now. Note if persisting here fails,
                    // it's not a big deal since we can always find it again form
                    // blockchain.
-                    db.lock().unwrap().stage_and_commit(C::from((
+                    db.lock().unwrap().stage(C::from((
                        local_chain::ChangeSet::default(),
                        keychain_changeset,
-                    )))?;
+                    )));
                    Ok(())
                }
                Err(e) => {
                    if let Some((keychain, index)) = change_index {
                        // We failed to broadcast, so allow our change address to be used in the future
-                        graph.lock().unwrap().index.unmark_used(keychain, index);
+                        graph.lock().unwrap().index.unmark_used(&keychain, index);
                    }
                    Err(e)
                }
@@ -658,26 +645,17 @@ where
    }
 }

-/// The initial state returned by [`init`].
-pub struct Init<CS: clap::Subcommand, S: clap::Args, C> {
-    /// Arguments parsed by the cli.
-    pub args: Args<CS, S>,
-    /// Descriptor keymap.
-    pub keymap: KeyMap,
-    /// Keychain-txout index.
-    pub index: KeychainTxOutIndex<Keychain>,
-    /// Persistence backend.
-    pub db: Mutex<Database<C>>,
-    /// Initial changeset.
-    pub init_changeset: C,
-}
-
-/// Parses command line arguments and initializes all components, creating
-/// a file store with the given parameters, or loading one if it exists.
-pub fn init<CS: clap::Subcommand, S: clap::Args, C>(
-    db_magic: &[u8],
+#[allow(clippy::type_complexity)]
+pub fn init<'m, CS: clap::Subcommand, S: clap::Args, C>(
+    db_magic: &'m [u8],
    db_default_path: &str,
-) -> anyhow::Result<Init<CS, S, C>>
+) -> anyhow::Result<(
+    Args<CS, S>,
+    KeyMap,
+    KeychainTxOutIndex<Keychain>,
+    Mutex<Database<'m, C>>,
+    C,
+)>
 where
    C: Default + Append + Serialize + DeserializeOwned,
 {
@@ -703,7 +681,7 @@ where
        index.add_keychain(Keychain::Internal, internal_descriptor);
    }

-    let mut db_backend = match Store::<C>::open_or_create_new(db_magic, &args.db_path) {
+    let mut db_backend = match Store::<'m, C>::open_or_create_new(db_magic, &args.db_path) {
        Ok(db_backend) => db_backend,
        // we cannot return `err` directly as it has lifetime `'m`
        Err(err) => return Err(anyhow::anyhow!("failed to init db backend: {:?}", err)),
@@ -711,11 +689,11 @@ where

    let init_changeset = db_backend.load_from_persistence()?.unwrap_or_default();

-    Ok(Init {
+    Ok((
        args,
        keymap,
        index,
-        db: Mutex::new(Database::new(db_backend)),
+        Mutex::new(Database::new(db_backend)),
        init_changeset,
-    })
+    ))
 }
--- a/example-crates/example_electrum/src/main.rs
+++ b/example-crates/example_electrum/src/main.rs
@@ -5,7 +5,7 @@ use std::{
 };

 use bdk_chain::{
-    bitcoin::{constants::genesis_block, Address, Network, OutPoint, Txid},
+    bitcoin::{Address, Network, OutPoint, ScriptBuf, Txid},
    indexed_tx_graph::{self, IndexedTxGraph},
    keychain,
    local_chain::{self, LocalChain},
@@ -103,15 +103,8 @@ type ChangeSet = (
 );

 fn main() -> anyhow::Result<()> {
-    let example_cli::Init {
-        args,
-        keymap,
-        index,
-        db,
-        init_changeset,
-    } = example_cli::init::<ElectrumCommands, ElectrumArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;
-
-    let (disk_local_chain, disk_tx_graph) = init_changeset;
+    let (args, keymap, index, db, (disk_local_chain, disk_tx_graph)) =
+        example_cli::init::<ElectrumCommands, ElectrumArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;

    let graph = Mutex::new({
        let mut graph = IndexedTxGraph::new(index);
@@ -119,17 +112,12 @@ fn main() -> anyhow::Result<()> {
        graph
    });

-    let chain = Mutex::new({
-        let genesis_hash = genesis_block(args.network).block_hash();
-        let (mut chain, _) = LocalChain::from_genesis_hash(genesis_hash);
-        chain.apply_changeset(&disk_local_chain)?;
-        chain
-    });
+    let chain = Mutex::new(LocalChain::from_changeset(disk_local_chain)?);

    let electrum_cmd = match &args.command {
        example_cli::Commands::ChainSpecific(electrum_cmd) => electrum_cmd,
        general_cmd => {
-            return example_cli::handle_commands(
+            let res = example_cli::handle_commands(
                &graph,
                &db,
                &chain,
@@ -142,6 +130,9 @@ fn main() -> anyhow::Result<()> {
                },
                general_cmd.clone(),
            );
+
+            db.lock().unwrap().commit()?;
+            return res;
        }
    };

@@ -159,7 +150,7 @@ fn main() -> anyhow::Result<()> {

                let keychain_spks = graph
                    .index
-                    .all_unbounded_spk_iters()
+                    .spks_of_all_keychains()
                    .into_iter()
                    .map(|(keychain, iter)| {
                        let mut first = true;
@@ -181,7 +172,14 @@ fn main() -> anyhow::Result<()> {
            };

            client
-                .full_scan(tip, keychain_spks, stop_gap, scan_options.batch_size)
+                .scan(
+                    tip,
+                    keychain_spks,
+                    core::iter::empty(),
+                    core::iter::empty(),
+                    stop_gap,
+                    scan_options.batch_size,
+                )
                .context("scanning the blockchain")?
        }
        ElectrumCommands::Sync {
@@ -210,28 +208,29 @@ fn main() -> anyhow::Result<()> {
            if all_spks {
                let all_spks = graph
                    .index
-                    .revealed_spks()
-                    .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                    .all_spks()
+                    .iter()
+                    .map(|(k, v)| (*k, v.clone()))
                    .collect::<Vec<_>>();
-                spks = Box::new(spks.chain(all_spks.into_iter().map(|(k, i, spk)| {
-                    eprintln!("scanning {}:{}", k, i);
-                    spk
+                spks = Box::new(spks.chain(all_spks.into_iter().map(|(index, script)| {
+                    eprintln!("scanning {:?}", index);
+                    script
                })));
            }
            if unused_spks {
                let unused_spks = graph
                    .index
-                    .unused_spks()
-                    .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                    .unused_spks(..)
+                    .map(|(k, v)| (*k, ScriptBuf::from(v)))
                    .collect::<Vec<_>>();
-                spks = Box::new(spks.chain(unused_spks.into_iter().map(|(k, i, spk)| {
+                spks = Box::new(spks.chain(unused_spks.into_iter().map(|(index, script)| {
                    eprintln!(
-                        "Checking if address {} {}:{} has been used",
-                        Address::from_script(&spk, args.network).unwrap(),
-                        k,
-                        i,
+                        "Checking if address {} {:?} has been used",
+                        Address::from_script(&script, args.network).unwrap(),
+                        index
                    );
-                    spk
+
+                    script
                })));
            }

@@ -280,7 +279,7 @@ fn main() -> anyhow::Result<()> {
            drop((graph, chain));

            let electrum_update = client
-                .sync(tip, spks, txids, outpoints, scan_options.batch_size)
+                .scan_without_keychain(tip, spks, txids, outpoints, scan_options.batch_size)
                .context("scanning the blockchain")?;
            (electrum_update, BTreeMap::new())
        }
@@ -299,12 +298,12 @@ fn main() -> anyhow::Result<()> {
        relevant_txids.missing_full_txs(graph.graph())
    };

-    let mut graph_update = relevant_txids.into_tx_graph(&client, missing_txids)?;
    let now = std::time::UNIX_EPOCH
        .elapsed()
        .expect("must get time")
        .as_secs();
-    let _ = graph_update.update_last_seen_unconfirmed(now);
+
+    let graph_update = relevant_txids.into_tx_graph(&client, Some(now), missing_txids)?;

    let db_changeset = {
        let mut chain = chain.lock().unwrap();
--- a/example-crates/example_esplora/src/main.rs
+++ b/example-crates/example_esplora/src/main.rs
@@ -86,7 +86,7 @@ impl EsploraArgs {
            _ => panic!("unsupported network"),
        });

-        let client = esplora_client::Builder::new(esplora_url).build_blocking();
+        let client = esplora_client::Builder::new(esplora_url).build_blocking()?;
        Ok(client)
    }
 }
@@ -99,13 +99,8 @@ pub struct ScanOptions {
 }

 fn main() -> anyhow::Result<()> {
-    let example_cli::Init {
-        args,
-        keymap,
-        index,
-        db,
-        init_changeset,
-    } = example_cli::init::<EsploraCommands, EsploraArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;
+    let (args, keymap, index, db, init_changeset) =
+        example_cli::init::<EsploraCommands, EsploraArgs, ChangeSet>(DB_MAGIC, DB_PATH)?;

    let genesis_hash = genesis_block(args.network).block_hash();

@@ -130,7 +125,7 @@ fn main() -> anyhow::Result<()> {
        example_cli::Commands::ChainSpecific(esplora_cmd) => esplora_cmd,
        // These are general commands handled by example_cli. Execute the cmd and return.
        general_cmd => {
-            return example_cli::handle_commands(
+            let res = example_cli::handle_commands(
                &graph,
                &db,
                &chain,
@@ -145,6 +140,9 @@ fn main() -> anyhow::Result<()> {
                },
                general_cmd.clone(),
            );
+
+            db.lock().unwrap().commit()?;
+            return res;
        }
    };

@@ -167,7 +165,7 @@ fn main() -> anyhow::Result<()> {
                .lock()
                .expect("mutex must not be poisoned")
                .index
-                .all_unbounded_spk_iters()
+                .spks_of_all_keychains()
                .into_iter()
                // This `map` is purely for logging.
                .map(|(keychain, iter)| {
@@ -189,14 +187,16 @@ fn main() -> anyhow::Result<()> {
            // is reached. It returns a `TxGraph` update (`graph_update`) and a structure that
            // represents the last active spk derivation indices of keychains
            // (`keychain_indices_update`).
-            let (mut graph_update, last_active_indices) = client
-                .full_scan(keychain_spks, *stop_gap, scan_options.parallel_requests)
+            let (graph_update, last_active_indices) = client
+                .scan_txs_with_keychains(
+                    keychain_spks,
+                    core::iter::empty(),
+                    core::iter::empty(),
+                    *stop_gap,
+                    scan_options.parallel_requests,
+                )
                .context("scanning for transactions")?;

-            // We want to keep track of the latest time a transaction was seen unconfirmed.
-            let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-            let _ = graph_update.update_last_seen_unconfirmed(now);
-
            let mut graph = graph.lock().expect("mutex must not be poisoned");
            // Because we did a stop gap based scan we are likely to have some updates to our
            // deriviation indices. Usually before a scan you are on a fresh wallet with no
@@ -241,32 +241,32 @@ fn main() -> anyhow::Result<()> {
                if *all_spks {
                    let all_spks = graph
                        .index
-                        .revealed_spks()
-                        .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                        .all_spks()
+                        .iter()
+                        .map(|(k, v)| (*k, v.clone()))
                        .collect::<Vec<_>>();
-                    spks = Box::new(spks.chain(all_spks.into_iter().map(|(k, i, spk)| {
-                        eprintln!("scanning {}:{}", k, i);
+                    spks = Box::new(spks.chain(all_spks.into_iter().map(|(index, script)| {
+                        eprintln!("scanning {:?}", index);
                        // Flush early to ensure we print at every iteration.
                        let _ = io::stderr().flush();
-                        spk
+                        script
                    })));
                }
                if unused_spks {
                    let unused_spks = graph
                        .index
-                        .unused_spks()
-                        .map(|(k, i, spk)| (k, i, spk.to_owned()))
+                        .unused_spks(..)
+                        .map(|(k, v)| (*k, v.to_owned()))
                        .collect::<Vec<_>>();
-                    spks = Box::new(spks.chain(unused_spks.into_iter().map(|(k, i, spk)| {
+                    spks = Box::new(spks.chain(unused_spks.into_iter().map(|(index, script)| {
                        eprintln!(
-                            "Checking if address {} {}:{} has been used",
-                            Address::from_script(&spk, args.network).unwrap(),
-                            k,
-                            i,
+                            "Checking if address {} {:?} has been used",
+                            Address::from_script(&script, args.network).unwrap(),
+                            index
                        );
                        // Flush early to ensure we print at every iteration.
                        let _ = io::stderr().flush();
-                        spk
+                        script
                    })));
                }
                if utxos {
@@ -311,12 +311,8 @@ fn main() -> anyhow::Result<()> {
                }
            }

-            let mut graph_update =
-                client.sync(spks, txids, outpoints, scan_options.parallel_requests)?;
-
-            // Update last seen unconfirmed
-            let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-            let _ = graph_update.update_last_seen_unconfirmed(now);
+            let graph_update =
+                client.scan_txs(spks, txids, outpoints, scan_options.parallel_requests)?;

            graph.lock().unwrap().apply_update(graph_update)
        }
--- a/example-crates/wallet_electrum/src/main.rs
+++ b/example-crates/wallet_electrum/src/main.rs
@@ -40,7 +40,7 @@ fn main() -> Result<(), anyhow::Error> {

    let prev_tip = wallet.latest_checkpoint();
    let keychain_spks = wallet
-        .all_unbounded_spk_iters()
+        .spks_of_all_keychains()
        .into_iter()
        .map(|(k, k_spks)| {
            let mut once = Some(());
@@ -61,14 +61,12 @@ fn main() -> Result<(), anyhow::Error> {
            relevant_txids,
        },
        keychain_update,
-    ) = client.full_scan(prev_tip, keychain_spks, STOP_GAP, BATCH_SIZE)?;
+    ) = client.scan(prev_tip, keychain_spks, None, None, STOP_GAP, BATCH_SIZE)?;

    println!();

    let missing = relevant_txids.missing_full_txs(wallet.as_ref());
-    let mut graph_update = relevant_txids.into_confirmation_time_tx_graph(&client, missing)?;
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-    let _ = graph_update.update_last_seen_unconfirmed(now);
+    let graph_update = relevant_txids.into_confirmation_time_tx_graph(&client, None, missing)?;

    let wallet_update = Update {
        last_active_indices: keychain_update,
@@ -101,7 +99,7 @@ fn main() -> Result<(), anyhow::Error> {
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    assert!(finalized);

-    let tx = psbt.extract_tx()?;
+    let tx = psbt.extract_tx();
    client.transaction_broadcast(&tx)?;
    println!("Tx broadcasted! Txid: {}", tx.txid());

--- a/example-crates/wallet_esplora_async/src/main.rs
+++ b/example-crates/wallet_esplora_async/src/main.rs
@@ -39,7 +39,7 @@ async fn main() -> Result<(), anyhow::Error> {

    let prev_tip = wallet.latest_checkpoint();
    let keychain_spks = wallet
-        .all_unbounded_spk_iters()
+        .spks_of_all_keychains()
        .into_iter()
        .map(|(k, k_spks)| {
            let mut once = Some(());
@@ -53,12 +53,9 @@ async fn main() -> Result<(), anyhow::Error> {
            (k, k_spks)
        })
        .collect();
-    let (mut update_graph, last_active_indices) = client
-        .full_scan(keychain_spks, STOP_GAP, PARALLEL_REQUESTS)
+    let (update_graph, last_active_indices) = client
+        .scan_txs_with_keychains(keychain_spks, None, None, STOP_GAP, PARALLEL_REQUESTS)
        .await?;
-
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-    let _ = update_graph.update_last_seen_unconfirmed(now);
    let missing_heights = update_graph.missing_heights(wallet.local_chain());
    let chain_update = client.update_local_chain(prev_tip, missing_heights).await?;
    let update = Update {
@@ -93,7 +90,7 @@ async fn main() -> Result<(), anyhow::Error> {
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    assert!(finalized);

-    let tx = psbt.extract_tx()?;
+    let tx = psbt.extract_tx();
    client.broadcast(&tx).await?;
    println!("Tx broadcasted! Txid: {}", tx.txid());

--- a/example-crates/wallet_esplora_blocking/src/main.rs
+++ b/example-crates/wallet_esplora_blocking/src/main.rs
@@ -34,11 +34,11 @@ fn main() -> Result<(), anyhow::Error> {

    print!("Syncing...");
    let client =
-        esplora_client::Builder::new("https://blockstream.info/testnet/api").build_blocking();
+        esplora_client::Builder::new("https://blockstream.info/testnet/api").build_blocking()?;

    let prev_tip = wallet.latest_checkpoint();
    let keychain_spks = wallet
-        .all_unbounded_spk_iters()
+        .spks_of_all_keychains()
        .into_iter()
        .map(|(k, k_spks)| {
            let mut once = Some(());
@@ -53,11 +53,8 @@ fn main() -> Result<(), anyhow::Error> {
        })
        .collect();

-    let (mut update_graph, last_active_indices) =
-        client.full_scan(keychain_spks, STOP_GAP, PARALLEL_REQUESTS)?;
-
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-    let _ = update_graph.update_last_seen_unconfirmed(now);
+    let (update_graph, last_active_indices) =
+        client.scan_txs_with_keychains(keychain_spks, None, None, STOP_GAP, PARALLEL_REQUESTS)?;
    let missing_heights = update_graph.missing_heights(wallet.local_chain());
    let chain_update = client.update_local_chain(prev_tip, missing_heights)?;
    let update = Update {
@@ -93,7 +90,7 @@ fn main() -> Result<(), anyhow::Error> {
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    assert!(finalized);

-    let tx = psbt.extract_tx()?;
+    let tx = psbt.extract_tx();
    client.broadcast(&tx)?;
    println!("Tx broadcasted! Txid: {}", tx.txid());

--- a/example-crates/wallet_rpc/Cargo.toml
+++ b/example-crates/wallet_rpc/Cargo.toml
@@ -1,15 +0,0 @@
-[package]
-name = "wallet_rpc"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bdk = { path = "../../crates/bdk" }
-bdk_file_store = { path = "../../crates/file_store" }
-bdk_bitcoind_rpc = { path = "../../crates/bitcoind_rpc" }
-
-anyhow = "1"
-clap = { version = "3.2.25", features = ["derive", "env"] }
-ctrlc = "2.0.1"
--- a/example-crates/wallet_rpc/README.md
+++ b/example-crates/wallet_rpc/README.md
@@ -1,45 +0,0 @@
-# Wallet RPC Example 
-
-```
-$ cargo run --bin wallet_rpc -- --help
-
-wallet_rpc 0.1.0
-Bitcoind RPC example using `bdk::Wallet`
-
-USAGE:
-    wallet_rpc [OPTIONS] <DESCRIPTOR> [CHANGE_DESCRIPTOR]
-
-ARGS:
-    <DESCRIPTOR>           Wallet descriptor [env: DESCRIPTOR=]
-    <CHANGE_DESCRIPTOR>    Wallet change descriptor [env: CHANGE_DESCRIPTOR=]
-
-OPTIONS:
-        --db-path <DB_PATH>
-            Where to store wallet data [env: BDK_DB_PATH=] [default: .bdk_wallet_rpc_example.db]
-
-    -h, --help
-            Print help information
-
-        --network <NETWORK>
-            Bitcoin network to connect to [env: BITCOIN_NETWORK=] [default: testnet]
-
-        --rpc-cookie <RPC_COOKIE>
-            RPC auth cookie file [env: RPC_COOKIE=]
-
-        --rpc-pass <RPC_PASS>
-            RPC auth password [env: RPC_PASS=]
-
-        --rpc-user <RPC_USER>
-            RPC auth username [env: RPC_USER=]
-
-        --start-height <START_HEIGHT>
-            Earliest block height to start sync from [env: START_HEIGHT=] [default: 481824]
-
-        --url <URL>
-            RPC URL [env: RPC_URL=] [default: 127.0.0.1:8332]
-
-    -V, --version
-            Print version information
-
-```
-
--- a/example-crates/wallet_rpc/src/main.rs
+++ b/example-crates/wallet_rpc/src/main.rs
@@ -1,182 +0,0 @@
-use bdk::{
-    bitcoin::{Block, Network, Transaction},
-    wallet::Wallet,
-};
-use bdk_bitcoind_rpc::{
-    bitcoincore_rpc::{Auth, Client, RpcApi},
-    Emitter,
-};
-use bdk_file_store::Store;
-use clap::{self, Parser};
-use std::{path::PathBuf, sync::mpsc::sync_channel, thread::spawn, time::Instant};
-
-const DB_MAGIC: &str = "bdk-rpc-wallet-example";
-
-/// Bitcoind RPC example using `bdk::Wallet`.
-///
-/// This syncs the chain block-by-block and prints the current balance, transaction count and UTXO
-/// count.
-#[derive(Parser, Debug)]
-#[clap(author, version, about, long_about = None)]
-#[clap(propagate_version = true)]
-pub struct Args {
-    /// Wallet descriptor
-    #[clap(env = "DESCRIPTOR")]
-    pub descriptor: String,
-    /// Wallet change descriptor
-    #[clap(env = "CHANGE_DESCRIPTOR")]
-    pub change_descriptor: Option<String>,
-    /// Earliest block height to start sync from
-    #[clap(env = "START_HEIGHT", long, default_value = "481824")]
-    pub start_height: u32,
-    /// Bitcoin network to connect to
-    #[clap(env = "BITCOIN_NETWORK", long, default_value = "testnet")]
-    pub network: Network,
-    /// Where to store wallet data
-    #[clap(
-        env = "BDK_DB_PATH",
-        long,
-        default_value = ".bdk_wallet_rpc_example.db"
-    )]
-    pub db_path: PathBuf,
-
-    /// RPC URL
-    #[clap(env = "RPC_URL", long, default_value = "127.0.0.1:8332")]
-    pub url: String,
-    /// RPC auth cookie file
-    #[clap(env = "RPC_COOKIE", long)]
-    pub rpc_cookie: Option<PathBuf>,
-    /// RPC auth username
-    #[clap(env = "RPC_USER", long)]
-    pub rpc_user: Option<String>,
-    /// RPC auth password
-    #[clap(env = "RPC_PASS", long)]
-    pub rpc_pass: Option<String>,
-}
-
-impl Args {
-    fn client(&self) -> anyhow::Result<Client> {
-        Ok(Client::new(
-            &self.url,
-            match (&self.rpc_cookie, &self.rpc_user, &self.rpc_pass) {
-                (None, None, None) => Auth::None,
-                (Some(path), _, _) => Auth::CookieFile(path.clone()),
-                (_, Some(user), Some(pass)) => Auth::UserPass(user.clone(), pass.clone()),
-                (_, Some(_), None) => panic!("rpc auth: missing rpc_pass"),
-                (_, None, Some(_)) => panic!("rpc auth: missing rpc_user"),
-            },
-        )?)
-    }
-}
-
-#[derive(Debug)]
-enum Emission {
-    SigTerm,
-    Block(bdk_bitcoind_rpc::BlockEvent<Block>),
-    Mempool(Vec<(Transaction, u64)>),
-}
-
-fn main() -> anyhow::Result<()> {
-    let args = Args::parse();
-
-    let rpc_client = args.client()?;
-    println!(
-        "Connected to Bitcoin Core RPC at {:?}",
-        rpc_client.get_blockchain_info().unwrap()
-    );
-
-    let start_load_wallet = Instant::now();
-    let mut wallet = Wallet::new_or_load(
-        &args.descriptor,
-        args.change_descriptor.as_ref(),
-        Store::<bdk::wallet::ChangeSet>::open_or_create_new(DB_MAGIC.as_bytes(), args.db_path)?,
-        args.network,
-    )?;
-    println!(
-        "Loaded wallet in {}s",
-        start_load_wallet.elapsed().as_secs_f32()
-    );
-
-    let balance = wallet.get_balance();
-    println!("Wallet balance before syncing: {} sats", balance.total());
-
-    let wallet_tip = wallet.latest_checkpoint();
-    println!(
-        "Wallet tip: {} at height {}",
-        wallet_tip.hash(),
-        wallet_tip.height()
-    );
-
-    let (sender, receiver) = sync_channel::<Emission>(21);
-
-    let signal_sender = sender.clone();
-    ctrlc::set_handler(move || {
-        signal_sender
-            .send(Emission::SigTerm)
-            .expect("failed to send sigterm")
-    });
-
-    let emitter_tip = wallet_tip.clone();
-    spawn(move || -> Result<(), anyhow::Error> {
-        let mut emitter = Emitter::new(&rpc_client, emitter_tip, args.start_height);
-        while let Some(emission) = emitter.next_block()? {
-            sender.send(Emission::Block(emission))?;
-        }
-        sender.send(Emission::Mempool(emitter.mempool()?))?;
-        Ok(())
-    });
-
-    let mut blocks_received = 0_usize;
-    for emission in receiver {
-        match emission {
-            Emission::SigTerm => {
-                println!("Sigterm received, exiting...");
-                break;
-            }
-            Emission::Block(block_emission) => {
-                blocks_received += 1;
-                let height = block_emission.block_height();
-                let hash = block_emission.block_hash();
-                let connected_to = block_emission.connected_to();
-                let start_apply_block = Instant::now();
-                wallet.apply_block_connected_to(&block_emission.block, height, connected_to)?;
-                wallet.commit()?;
-                let elapsed = start_apply_block.elapsed().as_secs_f32();
-                println!(
-                    "Applied block {} at height {} in {}s",
-                    hash, height, elapsed
-                );
-            }
-            Emission::Mempool(mempool_emission) => {
-                let start_apply_mempool = Instant::now();
-                wallet.apply_unconfirmed_txs(mempool_emission.iter().map(|(tx, time)| (tx, *time)));
-                wallet.commit()?;
-                println!(
-                    "Applied unconfirmed transactions in {}s",
-                    start_apply_mempool.elapsed().as_secs_f32()
-                );
-                break;
-            }
-        }
-    }
-    let wallet_tip_end = wallet.latest_checkpoint();
-    let balance = wallet.get_balance();
-    println!(
-        "Synced {} blocks in {}s",
-        blocks_received,
-        start_load_wallet.elapsed().as_secs_f32(),
-    );
-    println!(
-        "Wallet tip is '{}:{}'",
-        wallet_tip_end.height(),
-        wallet_tip_end.hash()
-    );
-    println!("Wallet balance is {} sats", balance.total());
-    println!(
-        "Wallet has {} transactions and {} utxos",
-        wallet.transactions().count(),
-        wallet.list_unspent().count()
-    );
-
-    Ok(())
-}
--- a/nursery/coin_select/src/coin_selector.rs
+++ b/nursery/coin_select/src/coin_selector.rs
@@ -96,7 +96,7 @@ impl CoinSelectorOpt {
    ) -> Self {
        let mut tx = Transaction {
            input: vec![],
-            version: transaction::Version::ONE,
+            version: 1,
            lock_time: absolute::LockTime::ZERO,
            output: txouts.to_vec(),
        };
@@ -112,7 +112,7 @@ impl CoinSelectorOpt {
            target_value: if txouts.is_empty() {
                None
            } else {
-                Some(txouts.iter().map(|txout| txout.value.to_sat()).sum())
+                Some(txouts.iter().map(|txout| txout.value).sum())
            },
            ..Self::from_weights(
                base_weight.to_wu() as u32,
--- a/nursery/coin_select/src/lib.rs
+++ b/nursery/coin_select/src/lib.rs
@@ -12,7 +12,7 @@ use bdk_chain::{
    bitcoin,
    collections::{BTreeSet, HashMap},
 };
-use bitcoin::{absolute, transaction, Transaction, TxOut};
+use bitcoin::{absolute, Transaction, TxOut};
 use core::fmt::{Debug, Display};

 mod coin_selector;
@@ -29,5 +29,5 @@ pub const TXIN_BASE_WEIGHT: u32 = (32 + 4 + 4) * 4;
 // Shamelessly copied from
 // https://github.com/rust-bitcoin/rust-miniscript/blob/d5615acda1a7fdc4041a11c1736af139b8c7ebe8/src/util.rs#L8
 pub(crate) fn varint_size(v: usize) -> u32 {
-    bitcoin::VarInt(v as u64).size() as u32
+    bitcoin::VarInt(v as u64).len() as u32
 }
--- a/nursery/tmp_plan/src/lib.rs
+++ b/nursery/tmp_plan/src/lib.rs
@@ -17,13 +17,14 @@
 use bdk_chain::{bitcoin, collections::*, miniscript};
 use bitcoin::{
    absolute,
+    address::WitnessVersion,
    bip32::{DerivationPath, Fingerprint, KeySource},
    blockdata::transaction::Sequence,
    ecdsa,
    hashes::{hash160, ripemd160, sha256},
    secp256k1::Secp256k1,
    taproot::{self, LeafVersion, TapLeafHash},
-    ScriptBuf, TxIn, Witness, WitnessVersion,
+    ScriptBuf, TxIn, Witness,
 };
 use miniscript::{
    descriptor::{InnerXKey, Tr},
@@ -31,7 +32,7 @@ use miniscript::{
 };

 pub(crate) fn varint_len(v: usize) -> usize {
-    bitcoin::VarInt(v as u64).size() as usize
+    bitcoin::VarInt(v as u64).len() as usize
 }

 mod plan_impls;
--- a/nursery/tmp_plan/src/requirements.rs
+++ b/nursery/tmp_plan/src/requirements.rs
@@ -3,11 +3,12 @@ use core::ops::Deref;

 use bitcoin::{
    bip32,
-    hashes::{hash160, ripemd160, sha256, Hash},
+    hashes::{hash160, ripemd160, sha256},
    key::XOnlyPublicKey,
-    secp256k1::{Keypair, Message, PublicKey, Signing, Verification},
+    psbt::Prevouts,
+    secp256k1::{KeyPair, Message, PublicKey, Signing, Verification},
    sighash,
-    sighash::{EcdsaSighashType, Prevouts, SighashCache, TapSighashType},
+    sighash::{EcdsaSighashType, SighashCache, TapSighashType},
    taproot, Transaction, TxOut,
 };

@@ -162,11 +163,11 @@ impl RequiredSignatures<DescriptorPublicKey> {

                let tweak =
                    taproot::TapTweakHash::from_key_and_tweak(x_only_pubkey, merkle_root.clone());
-                let keypair = Keypair::from_secret_key(&secp, &secret_key.clone())
+                let keypair = KeyPair::from_secret_key(&secp, &secret_key.clone())
                    .add_xonly_tweak(&secp, &tweak.to_scalar())
                    .unwrap();

-                let msg = Message::from_digest(sighash.to_byte_array());
+                let msg = Message::from_slice(sighash.as_ref()).expect("Sighashes are 32 bytes");
                let sig = secp.sign_schnorr_no_aux_rand(&msg, &keypair);

                let bitcoin_sig = taproot::Signature {
@@ -208,8 +209,9 @@ impl RequiredSignatures<DescriptorPublicKey> {
                                todo!();
                            }
                        };
-                        let keypair = Keypair::from_secret_key(&secp, &secret_key.clone());
-                        let msg = Message::from_digest(sighash.to_byte_array());
+                        let keypair = KeyPair::from_secret_key(&secp, &secret_key.clone());
+                        let msg =
+                            Message::from_slice(sighash.as_ref()).expect("Sighashes are 32 bytes");
                        let sig = secp.sign_schnorr_no_aux_rand(&msg, &keypair);
                        let bitcoin_sig = taproot::Signature {
                            sig,