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
66 changed files with 1211 additions and 2810 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 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"
-          cargo update -p home --precise "0.5.5"
      - 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/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,6 @@ members = [
    "crates/electrum",
    "crates/esplora",
    "crates/bitcoind_rpc",
-    "crates/hwi",
    "example-crates/example_cli",
    "example-crates/example_electrum",
    "example-crates/example_esplora",
@@ -15,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,19 +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"
 ```

 ## 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.5"
+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,7 +10,7 @@ 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"
@@ -18,10 +18,11 @@ miniscript = { version = "10.0.0", features = ["serde"], default-features = fals
 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.9.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>

--- 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/template.rs
+++ b/crates/bdk/src/descriptor/template.rs
@@ -575,7 +575,7 @@ 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 });
@@ -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 });
--- 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/wallet/coin_selection.rs
+++ b/crates/bdk/src/wallet/coin_selection.rs
@@ -100,7 +100,6 @@
 //! # Ok::<(), anyhow::Error>(())
 //! ```

-use crate::chain::collections::HashSet;
 use crate::types::FeeRate;
 use crate::wallet::utils::IsDust;
 use crate::Utxo;
@@ -108,7 +107,6 @@ use crate::WeightedUtxo;

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

 use core::convert::TryInto;
@@ -713,25 +711,6 @@ 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;
@@ -742,7 +721,6 @@ mod test {

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

    use rand::rngs::StdRng;
@@ -821,14 +799,13 @@ 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: rng.gen_range(0..200000000),
@@ -852,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: 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 {
@@ -1503,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,
-                        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/mod.rs
+++ b/crates/bdk/src/wallet/mod.rs
@@ -11,7 +11,7 @@

 //! Wallet
 //!
-//! This module defines the [`Wallet`].
+//! This module defines the [`Wallet`] structure.
 use crate::collections::{BTreeMap, HashMap, HashSet};
 use alloc::{
    boxed::Box,
@@ -23,9 +23,7 @@ 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,
@@ -33,8 +31,8 @@ use bdk_chain::{
 use bitcoin::secp256k1::{All, Secp256k1};
 use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::{
-    absolute, Address, Block, Network, OutPoint, Script, ScriptBuf, Sequence, Transaction, TxOut,
-    Txid, Weight, Witness,
+    absolute, Address, Network, OutPoint, Script, ScriptBuf, Sequence, Transaction, TxOut, Txid,
+    Weight, Witness,
 };
 use bitcoin::{consensus::encode::serialize, BlockHash};
 use bitcoin::{constants::genesis_block, psbt};
@@ -52,6 +50,10 @@ 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)]
@@ -75,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.
@@ -235,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"),
        })
@@ -250,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"),
            })
@@ -264,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()
    }
@@ -280,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()
    }
@@ -298,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.
@@ -312,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),
        }
@@ -364,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.
 ///
@@ -440,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>(
@@ -511,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();
@@ -587,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 {
@@ -685,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),
            }),
@@ -710,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,
@@ -735,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,
@@ -762,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,
@@ -786,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)
            }
        };
@@ -823,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
@@ -862,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.
@@ -870,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()
    }

@@ -992,11 +900,12 @@ impl<D> Wallet<D> {
        })
    }

-    /// 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
    ///
@@ -1536,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,
@@ -1546,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,
@@ -1720,7 +1626,7 @@ 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)
@@ -1764,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),
                    _ => {}
                }
            }
@@ -2019,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);
            }
        }
    }
@@ -2038,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)?;
@@ -2252,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)
@@ -2306,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);
@@ -2382,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
@@ -2406,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 prioritied.
-    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> {
--- a/crates/bdk/src/wallet/signer.rs
+++ b/crates/bdk/src/wallet/signer.rs
@@ -80,7 +80,6 @@
 //! ```

 use crate::collections::BTreeMap;
-use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::cmp::Ordering;
@@ -163,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 {
@@ -191,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),
        }
    }
 }
@@ -215,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,
@@ -806,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.
@@ -820,6 +825,12 @@ pub enum TapLeavesOptions {
    None,
 }

+impl Default for TapLeavesOptions {
+    fn default() -> Self {
+        TapLeavesOptions::All
+    }
+}
+
 #[allow(clippy::derivable_impls)]
 impl Default for SignOptions {
    fn default() -> Self {
--- a/crates/bdk/src/wallet/tx_builder.rs
+++ b/crates/bdk/src/wallet/tx_builder.rs
@@ -811,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,
@@ -822,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) {
@@ -875,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,
@@ -886,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 {
--- a/crates/bdk/tests/wallet.rs
+++ b/crates/bdk/tests/wallet.rs
@@ -7,8 +7,8 @@ use bdk::signer::{SignOptions, SignerError};
 use bdk::wallet::coin_selection::{self, LargestFirstCoinSelection};
 use bdk::wallet::error::CreateTxError;
 use bdk::wallet::tx_builder::AddForeignUtxoError;
+use bdk::wallet::AddressIndex::*;
 use bdk::wallet::{AddressIndex, AddressInfo, Balance, Wallet};
-use bdk::wallet::{AddressIndex::*, NewError};
 use bdk::{FeeRate, KeychainKind};
 use bdk_chain::COINBASE_MATURITY;
 use bdk_chain::{BlockId, ConfirmationTime};
@@ -71,33 +71,19 @@ fn load_recovers_wallet() {
    let file_path = temp_dir.path().join("store.db");

    // create new wallet
-    let wallet_spk_index = {
+    let wallet_keychains = {
        let db = bdk_file_store::Store::create_new(DB_MAGIC, &file_path).expect("must create db");
-        let mut wallet = Wallet::new(get_test_tr_single_sig_xprv(), None, db, Network::Testnet)
-            .expect("must init wallet");
-
-        wallet.try_get_address(New).unwrap();
-        wallet.spk_index().clone()
+        let wallet =
+            Wallet::new(get_test_wpkh(), None, db, Network::Testnet).expect("must init wallet");
+        wallet.keychains().clone()
    };

    // recover wallet
    {
        let db = bdk_file_store::Store::open(DB_MAGIC, &file_path).expect("must recover db");
-        let wallet =
-            Wallet::load(get_test_tr_single_sig_xprv(), None, db).expect("must recover wallet");
+        let wallet = Wallet::load(get_test_wpkh(), None, db).expect("must recover wallet");
        assert_eq!(wallet.network(), Network::Testnet);
-        assert_eq!(wallet.spk_index().keychains(), wallet_spk_index.keychains());
-        assert_eq!(
-            wallet.spk_index().last_revealed_indices(),
-            wallet_spk_index.last_revealed_indices()
-        );
-    }
-
-    // `new` can only be called on empty db
-    {
-        let db = bdk_file_store::Store::open(DB_MAGIC, &file_path).expect("must recover db");
-        let result = Wallet::new(get_test_tr_single_sig_xprv(), None, db, Network::Testnet);
-        assert!(matches!(result, Err(NewError::NonEmptyDatabase)));
+        assert_eq!(wallet.spk_index().keychains(), &wallet_keychains);
    }
 }

@@ -106,7 +92,7 @@ fn new_or_load() {
    let temp_dir = tempfile::tempdir().expect("must create tempdir");
    let file_path = temp_dir.path().join("store.db");

-    // init wallet when non-existent
+    // init wallet when non-existant
    let wallet_keychains = {
        let db = bdk_file_store::Store::open_or_create_new(DB_MAGIC, &file_path)
            .expect("must create db");
@@ -3591,6 +3577,41 @@ fn test_fee_rate_sign_grinding_low_r() {
    assert_fee_rate!(psbt, fee.unwrap_or(0), fee_rate);
 }

+// #[cfg(feature = "test-hardware-signer")]
+// #[test]
+// fn test_hardware_signer() {
+//     use std::sync::Arc;
+//
+//     use bdk::signer::SignerOrdering;
+//     use bdk::wallet::hardwaresigner::HWISigner;
+//     use hwi::types::HWIChain;
+//     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, HWIChain::Regtest).unwrap();
+//     let descriptors = client.get_descriptors::<String>(None).unwrap();
+//     let custom_signer = HWISigner::from_device(&device, HWIChain::Regtest).unwrap();
+//
+//     let (mut wallet, _) = get_funded_wallet(&descriptors.internal[0]);
+//     wallet.add_signer(
+//         KeychainKind::External,
+//         SignerOrdering(200),
+//         Arc::new(custom_signer),
+//     );
+//
+//     let addr = wallet.get_address(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);
+// }
+
 #[test]
 fn test_taproot_load_descriptor_duplicated_keys() {
    // Added after issue https://github.com/bitcoindevkit/bdk/issues/760
--- a/crates/bitcoind_rpc/Cargo.toml
+++ b/crates/bitcoind_rpc/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "bdk_bitcoind_rpc"
-version = "0.4.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"
@@ -16,7 +16,7 @@ readme = "README.md"
 # For no-std, remember to enable the bitcoin/no-std feature
 bitcoin = { version = "0.30", default-features = false }
 bitcoincore-rpc = { version = "0.17" }
-bdk_chain = { path = "../chain", version = "0.9", default-features = false }
+bdk_chain = { path = "../chain", version = "0.6", default-features = false }

 [dev-dependencies]
 bitcoind = { version = "0.33", features = ["25_0"] }
--- 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
@@ -157,6 +157,28 @@ impl TestEnv {
    }
 }

+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.
 ///
 /// 1. Mine 101 blocks.
@@ -178,21 +200,17 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {

    // 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",
        );
    }
@@ -219,30 +237,27 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
    // 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",
        );
@@ -292,13 +307,9 @@ fn test_into_tx_graph() -> anyhow::Result<()> {

    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());
    }

@@ -356,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);
@@ -399,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"
        );
@@ -434,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(())
 }
@@ -656,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 {
@@ -751,8 +754,7 @@ fn mempool_during_reorg() -> anyhow::Result<()> {
            .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
@@ -833,12 +835,12 @@ 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
@@ -853,7 +855,7 @@ fn no_agreement_point() -> anyhow::Result<()> {
    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.9.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"
--- a/crates/chain/src/chain_data.rs
+++ b/crates/chain/src/chain_data.rs
@@ -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(
@@ -188,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(
--- 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,22 +145,54 @@ 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
+    }
+
+    /// Convenience method to call [`set_lookahead`] for all keychains.
+    ///
+    /// [`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);
+        }
+    }
+
+    /// 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`.
@@ -332,14 +201,22 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    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) {
-            self.replenish_lookahead(keychain, temp_lookahead);
+            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, lookahead: u32) {
+    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)
@@ -354,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
@@ -520,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`.
@@ -598,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(),
@@ -612,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
@@ -5,10 +5,9 @@ use core::convert::Infallible;
 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`]).
@@ -40,28 +39,6 @@ impl CheckPoint {
        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,
@@ -150,7 +127,7 @@ impl CheckPoint {
    }
 }

-/// Iterates over checkpoints backwards.
+/// A structure that iterates over checkpoints backwards.
 pub struct CheckPointIter {
    current: Option<Arc<CPInner>>,
 }
@@ -176,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
@@ -370,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() {
@@ -532,28 +420,6 @@ 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> {
-        if self.index.get(&block_id.height) != Some(&block_id.hash) {
-            return Ok(ChangeSet::default());
-        }
-
-        let changeset = self
-            .index
-            .range(block_id.height..)
-            .map(|(&height, _)| (height, None))
-            .collect::<ChangeSet>();
-        self.apply_changeset(&changeset).map(|_| changeset)
-    }
-
    /// Reindex the heights in the chain from (and including) `from` height
    fn reindex(&mut self, from: u32) {
        let _ = self.index.split_off(&from);
@@ -669,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
-    ///
-    /// Convience 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
@@ -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>,
    {
--- 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,32 +1,12 @@
 //! 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 doesn't 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 it's anchored in (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 "canonical" (i.e., in the best chain or in mempool) transactions,
-//! we decide which transactions are canonical based on anchors `last_seen_unconfirmed`;
-//! 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
 //!
@@ -69,8 +49,6 @@
 //! 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,
@@ -113,7 +91,7 @@ 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.
@@ -150,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).
@@ -337,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)
@@ -497,7 +475,7 @@ impl<A: Clone + Ord> TxGraph<A> {
    /// 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,
@@ -581,7 +559,10 @@ impl<A: Clone + Ord> TxGraph<A> {
        }

        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 */
@@ -594,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;
            }
@@ -727,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
    ///
@@ -766,7 +735,7 @@ 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 {
@@ -976,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
    ///
@@ -1168,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.
@@ -1271,12 +1239,10 @@ impl<A> ChangeSet<A> {
 }

 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(
@@ -1306,7 +1272,7 @@ 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> {
@@ -1424,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)]
--- a/crates/chain/tests/test_indexed_tx_graph.rs
+++ b/crates/chain/tests/test_indexed_tx_graph.rs
@@ -27,10 +27,9 @@ 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![
@@ -119,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

--- a/crates/chain/tests/test_keychain_txout_index.rs
+++ b/crates/chain/tests/test_keychain_txout_index.rs
@@ -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,
    );
@@ -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()
@@ -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,7 +389,7 @@ 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,
    );
--- a/crates/chain/tests/test_local_chain.rs
+++ b/crates/chain/tests/test_local_chain.rs
@@ -1,11 +1,7 @@
-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 bitcoin::BlockHash;

 #[macro_use]
 mod common;
@@ -292,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);
@@ -375,307 +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 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);
-    }
-}
--- 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.7.0"
+version = "0.4.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -12,6 +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.9.0", default-features = false }
+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"] }
--- 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
@@ -56,14 +56,12 @@ 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,
@@ -136,63 +134,76 @@ 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> {
        let mut request_spks = keychain_spks
            .into_iter()
-            .map(|(k, s)| (k.clone(), s.into_iter()))
+            .map(|(k, s)| (k, s.into_iter()))
            .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();
@@ -231,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 {
@@ -264,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()?;
@@ -417,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 {
@@ -478,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) {
@@ -492,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");

@@ -514,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/esplora/Cargo.toml
+++ b/crates/esplora/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_esplora"
-version = "0.7.0"
+version = "0.4.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -12,7 +12,7 @@ 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.9.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 }
--- 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
@@ -2,14 +2,14 @@ use async_trait::async_trait;
 use bdk_chain::collections::btree_map;
 use bdk_chain::{
    bitcoin::{BlockHash, OutPoint, ScriptBuf, Txid},
-    collections::BTreeMap,
+    collections::{BTreeMap, BTreeSet},
    local_chain::{self, CheckPoint},
    BlockId, ConfirmationTimeHeightAnchor, TxGraph,
 };
 use esplora_client::{Error, TxStatus};
 use futures::{stream::FuturesOrdered, TryStreamExt};

-use crate::anchor_from_status;
+use crate::{anchor_from_status, ASSUME_FINAL_DEPTH};

 /// Trait to extend the functionality of [`esplora_client::AsyncClient`].
 ///
@@ -19,19 +19,13 @@ use crate::anchor_from_status;
 #[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
@@ -42,45 +36,58 @@ pub trait EsploraAsyncExt {
        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.
    #[allow(clippy::result_large_err)]
-    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>;

-    /// 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
+    /// [`scan_txs_with_keychains`]: EsploraAsyncExt::scan_txs_with_keychains
    #[allow(clippy::result_large_err)]
-    async fn sync(
+    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))]
@@ -91,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 {
@@ -114,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> {
@@ -223,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
@@ -297,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,7 +1,7 @@
 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::{BlockHash, OutPoint, ScriptBuf, Txid},
    local_chain::{self, CheckPoint},
@@ -9,7 +9,7 @@ use bdk_chain::{
 };
 use esplora_client::{Error, TxStatus};

-use crate::anchor_from_status;
+use crate::{anchor_from_status, ASSUME_FINAL_DEPTH};

 /// Trait to extend the functionality of [`esplora_client::BlockingClient`].
 ///
@@ -17,19 +17,13 @@ use crate::anchor_from_status;
 ///
 /// [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
@@ -40,42 +34,54 @@ pub trait EsploraExt {
        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.
-    #[allow(clippy::result_large_err)]
-    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.
-    ///
-    /// [`full_scan`]: EsploraExt::full_scan
+    /// 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 sync(
+    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.
+    ///
+    /// [`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 {
@@ -84,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 {
@@ -106,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> {
@@ -213,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
@@ -264,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);
@@ -289,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
@@ -101,7 +101,7 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {

    let graph_update = env
        .client
-        .sync(
+        .scan_txs(
            misc_spks.into_iter(),
            vec![].into_iter(),
            vec![].into_iter(),
@@ -166,10 +166,28 @@ pub async fn test_async_update_tx_graph_gap_limit() -> anyhow::Result<()> {

    // 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) = env.client.full_scan(keychains.clone(), 2, 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) = env.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(),
+            3,
+            1,
+        )
+        .await?;
    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
    assert_eq!(active_indices[&0], 3);

@@ -191,12 +209,24 @@ pub async fn test_async_update_tx_graph_gap_limit() -> anyhow::Result<()> {

    // 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) = env.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(),
+            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) = env.client.full_scan(keychains, 5, 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,31 +1,15 @@
-use bdk_chain::local_chain::LocalChain;
-use bdk_chain::BlockId;
 use bdk_esplora::EsploraExt;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
 use electrsd::bitcoind::{self, anyhow, BitcoinD};
 use electrsd::{Conf, ElectrsD};
 use esplora_client::{self, BlockingClient, Builder};
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::{BTreeMap, HashSet};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;

 use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};

-macro_rules! h {
-    ($index:literal) => {{
-        bdk_chain::bitcoin::hashes::Hash::hash($index.as_bytes())
-    }};
-}
-
-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")
-    }};
-}
-
 struct TestEnv {
    bitcoind: BitcoinD,
    #[allow(dead_code)]
@@ -55,20 +39,6 @@ impl TestEnv {
        })
    }

-    fn reset_electrsd(mut self) -> anyhow::Result<Self> {
-        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, &self.bitcoind, &electrs_conf)?;
-
-        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
-        let client = Builder::new(base_url.as_str()).build_blocking()?;
-        self.electrsd = electrsd;
-        self.client = client;
-        Ok(self)
-    }
-
    fn mine_blocks(
        &self,
        count: usize,
@@ -129,7 +99,7 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
        sleep(Duration::from_millis(10))
    }

-    let graph_update = env.client.sync(
+    let graph_update = env.client.scan_txs(
        misc_spks.into_iter(),
        vec![].into_iter(),
        vec![].into_iter(),
@@ -194,10 +164,22 @@ pub fn test_update_tx_graph_gap_limit() -> anyhow::Result<()> {

    // 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) = env.client.full_scan(keychains.clone(), 2, 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) = env.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(),
+        3,
+        1,
+    )?;
    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
    assert_eq!(active_indices[&0], 3);

@@ -219,12 +201,24 @@ pub fn test_update_tx_graph_gap_limit() -> anyhow::Result<()> {

    // 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) = env.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(),
+        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) = env.client.full_scan(keychains, 5, 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));
@@ -232,180 +226,3 @@ pub fn test_update_tx_graph_gap_limit() -> 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()?;
-
-    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 = env
-            .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.blocks().get(height),
-                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.5.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.9.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>,
    {
@@ -67,7 +67,7 @@ where
            .open(file_path)?;
        f.write_all(magic)?;
        Ok(Self {
-            magic_len: magic.len(),
+            magic,
            db_file: f,
            marker: Default::default(),
        })
@@ -83,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>,
    {
@@ -94,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>,
    {
@@ -132,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
@@ -219,7 +219,6 @@ mod test {

    use bincode::DefaultOptions;
    use std::{
-        collections::BTreeSet,
        io::{Read, Write},
        vec::Vec,
    };
@@ -229,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;
@@ -254,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)
@@ -305,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");
@@ -341,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.1.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.7.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::{FeeRate, 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::psbt::PartiallySignedTransaction;
-use bdk::bitcoin::secp256k1::{All, Secp256k1};
-
-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 PartiallySignedTransaction,
-        _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/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 {
@@ -117,11 +120,10 @@ fn main() -> anyhow::Result<()> {
        "[{:>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!(
@@ -129,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()
@@ -147,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,
@@ -160,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);
@@ -176,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
@@ -237,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!(
@@ -257,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;
                            }
@@ -266,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) {
@@ -295,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
@@ -29,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)]
@@ -73,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,
@@ -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)]
@@ -462,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);
@@ -482,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(())
@@ -605,16 +601,17 @@ where
                    // 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)
@@ -630,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)
                }
@@ -649,14 +646,14 @@ where
 }

 #[allow(clippy::type_complexity)]
-pub fn init<CS: clap::Subcommand, S: clap::Args, C>(
-    db_magic: &[u8],
+pub fn init<'m, CS: clap::Subcommand, S: clap::Args, C>(
+    db_magic: &'m [u8],
    db_default_path: &str,
 ) -> anyhow::Result<(
    Args<CS, S>,
    KeyMap,
    KeychainTxOutIndex<Keychain>,
-    Mutex<Database<C>>,
+    Mutex<Database<'m, C>>,
    C,
 )>
 where
@@ -684,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)),
--- 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},
@@ -112,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,
@@ -135,6 +130,9 @@ fn main() -> anyhow::Result<()> {
                },
                general_cmd.clone(),
            );
+
+            db.lock().unwrap().commit()?;
+            return res;
        }
    };

@@ -152,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;
@@ -174,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 {
@@ -203,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
                })));
            }

@@ -273,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())
        }
--- a/example-crates/example_esplora/src/main.rs
+++ b/example-crates/example_esplora/src/main.rs
@@ -125,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,
@@ -140,6 +140,9 @@ fn main() -> anyhow::Result<()> {
                },
                general_cmd.clone(),
            );
+
+            db.lock().unwrap().commit()?;
+            return res;
        }
    };

@@ -162,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)| {
@@ -185,7 +188,13 @@ fn main() -> anyhow::Result<()> {
            // represents the last active spk derivation indices of keychains
            // (`keychain_indices_update`).
            let (graph_update, last_active_indices) = client
-                .full_scan(keychain_spks, *stop_gap, scan_options.parallel_requests)
+                .scan_txs_with_keychains(
+                    keychain_spks,
+                    core::iter::empty(),
+                    core::iter::empty(),
+                    *stop_gap,
+                    scan_options.parallel_requests,
+                )
                .context("scanning for transactions")?;

            let mut graph = graph.lock().expect("mutex must not be poisoned");
@@ -232,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 {
@@ -303,7 +312,7 @@ fn main() -> anyhow::Result<()> {
            }

            let graph_update =
-                client.sync(spks, txids, outpoints, scan_options.parallel_requests)?;
+                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,7 +61,7 @@ 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!();

--- 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(());
@@ -54,7 +54,7 @@ async fn main() -> Result<(), anyhow::Error> {
        })
        .collect();
    let (update_graph, last_active_indices) = client
-        .full_scan(keychain_spks, STOP_GAP, PARALLEL_REQUESTS)
+        .scan_txs_with_keychains(keychain_spks, None, None, STOP_GAP, PARALLEL_REQUESTS)
        .await?;
    let missing_heights = update_graph.missing_heights(wallet.local_chain());
    let chain_update = client.update_local_chain(prev_tip, missing_heights).await?;
--- a/example-crates/wallet_esplora_blocking/src/main.rs
+++ b/example-crates/wallet_esplora_blocking/src/main.rs
@@ -38,7 +38,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(());
@@ -54,7 +54,7 @@ fn main() -> Result<(), anyhow::Error> {
        .collect();

    let (update_graph, last_active_indices) =
-        client.full_scan(keychain_spks, STOP_GAP, PARALLEL_REQUESTS)?;
+        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 {
--- 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 usign `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 usign `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(())
-}