chore(deps): bump actions/checkout from 1 to 4

Bumps [actions/checkout](https://github.com/actions/checkout) from 1 to 4. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v1...v4) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>
2024-03-16 22:30:32 +00:00
79 changed files with 3303 additions and 4837 deletions
--- a/.github/workflows/audit.yml
+++ b/.github/workflows/audit.yml
@@ -13,7 +13,7 @@ jobs:
  security_audit:
    runs-on: ubuntu-20.04
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
      - uses: actions-rs/audit-check@v1
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -13,7 +13,7 @@ jobs:

    steps:
      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Install lcov tools
        run: sudo apt-get install lcov -y
      - name: Install Rust toolchain
--- a/.github/workflows/cont_integration.yml
+++ b/.github/workflows/cont_integration.yml
@@ -18,7 +18,7 @@ jobs:
          - --all-features
    steps:
      - name: checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
@@ -33,7 +33,6 @@ jobs:
          cargo update -p zstd-sys --precise "2.0.8+zstd.1.5.5"
          cargo update -p time --precise "0.3.20"
          cargo update -p home --precise "0.5.5"
-          cargo update -p proptest --precise "1.2.0"
      - name: Build
        run: cargo build ${{ matrix.features }}
      - name: Test
@@ -44,7 +43,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
@@ -75,7 +74,7 @@ jobs:
      CFLAGS: -I/usr/include
    steps:
      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        # Install a recent version of clang that supports wasm32
      - run: wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add - || exit 1
      - run: sudo apt-get update || exit 1
@@ -101,7 +100,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
@@ -115,7 +114,7 @@ jobs:
  clippy_check:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
            toolchain: stable
--- a/.github/workflows/nightly_docs.yml
+++ b/.github/workflows/nightly_docs.yml
@@ -8,7 +8,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
      - name: Set default toolchain
        run: rustup default nightly-2022-12-14
      - name: Set profile
@@ -17,8 +17,6 @@ jobs:
        run: rustup update
      - name: Rust Cache
        uses: Swatinem/rust-cache@v2.2.1
-      - name: Pin dependencies for MSRV
-        run: cargo update -p home --precise "0.5.5"
      - name: Build docs
        run: cargo doc --no-deps
        env:
@@ -36,7 +34,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout `bitcoindevkit.org`
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          ssh-key: ${{ secrets.DOCS_PUSH_SSH_KEY }}
          repository: bitcoindevkit/bitcoindevkit.org
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,8 +8,6 @@ members = [
    "crates/esplora",
    "crates/bitcoind_rpc",
    "crates/hwi",
-    "crates/persist",
-    "crates/testenv",
    "example-crates/example_cli",
    "example-crates/example_electrum",
    "example-crates/example_esplora",
--- a/README.md
+++ b/README.md
@@ -41,7 +41,6 @@ The project is split up into several crates in the `/crates` directory:

 - [`bdk`](./crates/bdk): Contains the central high level `Wallet` type that is built from the low-level mechanisms provided by the other components
 - [`chain`](./crates/chain): Tools for storing and indexing chain data
- [`persist`](./crates/persist): Types that define data persistence of a BDK wallet
 - [`file_store`](./crates/file_store): A (experimental) persistence backend for storing chain data in a single file.
 - [`esplora`](./crates/esplora): Extends the [`esplora-client`] crate with methods to fetch chain data from an esplora HTTP server in the form that [`bdk_chain`] and `Wallet` can consume.
 - [`electrum`](./crates/electrum): Extends the [`electrum-client`] crate with methods to fetch chain data from an electrum server in the form that [`bdk_chain`] and `Wallet` can consume.
@@ -76,8 +75,6 @@ cargo update -p time --precise "0.3.20"
 cargo update -p jobserver --precise "0.1.26"
 # home 0.5.9 has MSRV 1.70.0
 cargo update -p home --precise "0.5.5"
-# proptest 1.4.0 has MSRV 1.65.0
-cargo update -p proptest --precise "1.2.0"
 ```

 ## License
--- a/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.10"
+version = "1.0.0-alpha.7"
 repository = "https://github.com/bitcoindevkit/bdk"
 documentation = "https://docs.rs/bdk"
 description = "A modern, lightweight, descriptor-based wallet library"
@@ -13,14 +13,12 @@ edition = "2021"
 rust-version = "1.63"

 [dependencies]
-anyhow = { version = "1", default-features = false }
 rand = "^0.8"
-miniscript = { version = "11.0.0", features = ["serde"], default-features = false }
-bitcoin = { version = "0.31.0", features = ["serde", "base64", "rand-std"], default-features = false }
+miniscript = { version = "10.0.0", features = ["serde"], default-features = false }
+bitcoin = { version = "0.30.0", features = ["serde", "base64", "rand-std"], default-features = false }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
-bdk_chain = { path = "../chain", version = "0.13.0", features = ["miniscript", "serde"], default-features = false }
-bdk_persist = { path = "../persist", version = "0.1.0" }
+bdk_chain = { path = "../chain", version = "0.11.0", features = ["miniscript", "serde"], default-features = false }

 # Optional dependencies
 bip39 = { version = "2.0", optional = true }
--- a/crates/bdk/README.md
+++ b/crates/bdk/README.md
@@ -26,7 +26,7 @@

 ## `bdk`

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

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

 ### Blockchain data

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

 **Blockchain Data Sources**

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

 **Examples**

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

 ### Persistence

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

 **Implementations**

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

 **Example**

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

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

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

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

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

-[`Wallet`]: https://docs.rs/bdk/1.0.0-alpha.7/bdk/wallet/struct.Wallet.html
-[`PersistBackend`]: https://docs.rs/bdk_persist/latest/bdk_persist/trait.PersistBackend.html
 [`bdk_chain`]: https://docs.rs/bdk_chain/latest
 [`bdk_file_store`]: https://docs.rs/bdk_file_store/latest
 [`bdk_electrum`]: https://docs.rs/bdk_electrum/latest
 [`bdk_esplora`]: https://docs.rs/bdk_esplora/latest
-[`bdk_bitcoind_rpc`]: https://docs.rs/bdk_bitcoind_rpc/latest
+[`KeychainScan`]: https://docs.rs/bdk_chain/latest/bdk_chain/keychain/struct.KeychainScan.html
 [`rust-miniscript`]: https://docs.rs/miniscript/latest/miniscript/index.html
--- a/crates/bdk/examples/compiler.rs
+++ b/crates/bdk/examples/compiler.rs
@@ -21,6 +21,7 @@ use bitcoin::Network;
 use miniscript::policy::Concrete;
 use miniscript::Descriptor;

+use bdk::wallet::AddressIndex::New;
 use bdk::{KeychainKind, Wallet};

 /// Miniscript policy is a high level abstraction of spending conditions. Defined in the
@@ -50,7 +51,7 @@ fn main() -> Result<(), Box<dyn Error>> {

    println!(
        "First derived address from the descriptor: \n{}",
-        wallet.next_unused_address(KeychainKind::External)?,
+        wallet.get_address(New)
    );

    // BDK also has it's own `Policy` structure to represent the spending condition in a more
--- a/crates/bdk/src/descriptor/dsl.rs
+++ b/crates/bdk/src/descriptor/dsl.rs
@@ -274,13 +274,14 @@ macro_rules! impl_sortedmulti {
 #[macro_export]
 macro_rules! parse_tap_tree {
    ( @merge $tree_a:expr, $tree_b:expr) => {{
+        use $crate::alloc::sync::Arc;
        use $crate::miniscript::descriptor::TapTree;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        let mut path_found = None;

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

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

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

        let secp = Secp256k1::new();

-        let xprv = bip32::Xpriv::from_str("xprv9s21ZrQH143K3c3gF1DUWpWNr2SG2XrG8oYPpqYh7hoWsJy9NjabErnzriJPpnGHyKz5NgdXmq1KVbqS1r4NXdCoKitWg5e86zqXHa8kxyB").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3c3gF1DUWpWNr2SG2XrG8oYPpqYh7hoWsJy9NjabErnzriJPpnGHyKz5NgdXmq1KVbqS1r4NXdCoKitWg5e86zqXHa8kxyB").unwrap();
        let path = bip32::DerivationPath::from_str("m/0").unwrap();

        // here `to_descriptor_key` will set the valid networks for the key to only mainnet, since
@@ -745,7 +746,7 @@ mod test {
        let mut xprv_testnet = xprv;
        xprv_testnet.network = Network::Testnet;

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

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

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

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

-                if tr.tap_tree().is_none() {
+                if tr.taptree().is_none() {
                    Ok(Some(key_spend_sig))
                } else {
                    let mut items = vec![key_spend_sig];
@@ -1184,8 +1184,8 @@ mod test {
        secp: &SecpCtx,
    ) -> (DescriptorKey<Ctx>, DescriptorKey<Ctx>, Fingerprint) {
        let path = bip32::DerivationPath::from_str(path).unwrap();
-        let tprv = bip32::Xpriv::from_str(tprv).unwrap();
-        let tpub = bip32::Xpub::from_priv(secp, &tprv);
+        let tprv = bip32::ExtendedPrivKey::from_str(tprv).unwrap();
+        let tpub = bip32::ExtendedPubKey::from_priv(secp, &tprv);
        let fingerprint = tprv.fingerprint(secp);
        let prvkey = (tprv, path.clone()).into_descriptor_key().unwrap();
        let pubkey = (tpub, path).into_descriptor_key().unwrap();
--- a/crates/bdk/src/descriptor/template.rs
+++ b/crates/bdk/src/descriptor/template.rs
@@ -74,7 +74,7 @@ impl<T: DescriptorTemplate> IntoWalletDescriptor for T {
 /// ```
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::Wallet;
-/// # use bdk::KeychainKind;
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::P2Pkh;
 ///
 /// let key =
@@ -82,9 +82,7 @@ impl<T: DescriptorTemplate> IntoWalletDescriptor for T {
 /// let mut wallet = Wallet::new_no_persist(P2Pkh(key), None, Network::Testnet)?;
 ///
 /// assert_eq!(
-///     wallet
-///         .next_unused_address(KeychainKind::External)?
-///         .to_string(),
+///     wallet.get_address(New).to_string(),
 ///     "mwJ8hxFYW19JLuc65RCTaP4v1rzVU8cVMT"
 /// );
 /// # Ok::<_, Box<dyn std::error::Error>>(())
@@ -104,17 +102,15 @@ impl<K: IntoDescriptorKey<Legacy>> DescriptorTemplate for P2Pkh<K> {
 /// ```
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::Wallet;
-/// # use bdk::KeychainKind;
 /// use bdk::template::P2Wpkh_P2Sh;
+/// use bdk::wallet::AddressIndex;
 ///
 /// let key =
 ///     bitcoin::PrivateKey::from_wif("cTc4vURSzdx6QE6KVynWGomDbLaA75dNALMNyfjh3p8DRRar84Um")?;
 /// let mut wallet = Wallet::new_no_persist(P2Wpkh_P2Sh(key), None, Network::Testnet)?;
 ///
 /// assert_eq!(
-///     wallet
-///         .next_unused_address(KeychainKind::External)?
-///         .to_string(),
+///     wallet.get_address(AddressIndex::New).to_string(),
 ///     "2NB4ox5VDRw1ecUv6SnT3VQHPXveYztRqk5"
 /// );
 /// # Ok::<_, Box<dyn std::error::Error>>(())
@@ -135,17 +131,15 @@ impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh_P2Sh<K> {
 /// ```
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet};
-/// # use bdk::KeychainKind;
 /// use bdk::template::P2Wpkh;
+/// use bdk::wallet::AddressIndex::New;
 ///
 /// let key =
 ///     bitcoin::PrivateKey::from_wif("cTc4vURSzdx6QE6KVynWGomDbLaA75dNALMNyfjh3p8DRRar84Um")?;
 /// let mut wallet = Wallet::new_no_persist(P2Wpkh(key), None, Network::Testnet)?;
 ///
 /// assert_eq!(
-///     wallet
-///         .next_unused_address(KeychainKind::External)?
-///         .to_string(),
+///     wallet.get_address(New).to_string(),
 ///     "tb1q4525hmgw265tl3drrl8jjta7ayffu6jf68ltjd"
 /// );
 /// # Ok::<_, Box<dyn std::error::Error>>(())
@@ -165,7 +159,7 @@ impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh<K> {
 /// ```
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::Wallet;
-/// # use bdk::KeychainKind;
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::P2TR;
 ///
 /// let key =
@@ -173,9 +167,7 @@ impl<K: IntoDescriptorKey<Segwitv0>> DescriptorTemplate for P2Wpkh<K> {
 /// let mut wallet = Wallet::new_no_persist(P2TR(key), None, Network::Testnet)?;
 ///
 /// assert_eq!(
-///     wallet
-///         .next_unused_address(KeychainKind::External)?
-///         .to_string(),
+///     wallet.get_address(New).to_string(),
 ///     "tb1pvjf9t34fznr53u5tqhejz4nr69luzkhlvsdsdfq9pglutrpve2xq7hps46"
 /// );
 /// # Ok::<_, Box<dyn std::error::Error>>(())
@@ -200,16 +192,17 @@ impl<K: IntoDescriptorKey<Tap>> DescriptorTemplate for P2TR<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip44;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip44(key.clone(), KeychainKind::External),
 ///     Some(Bip44(key, KeychainKind::Internal)),
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "mmogjc7HJEZkrLqyQYqJmxUqFaC7i4uf89");
+/// assert_eq!(wallet.get_address(New).to_string(), "mmogjc7HJEZkrLqyQYqJmxUqFaC7i4uf89");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "pkh([c55b303f/44'/1'/0']tpubDCuorCpzvYS2LCD75BR46KHE8GdDeg1wsAgNZeNr6DaB5gQK1o14uErKwKLuFmeemkQ6N2m3rNgvctdJLyr7nwu2yia7413Hhg8WWE44cgT/0/*)#5wrnv0xt");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -236,9 +229,10 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip44Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip44Public(key.clone(), fingerprint, KeychainKind::External),
@@ -246,7 +240,7 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44<K> {
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "miNG7dJTzJqNbFS19svRdTCisC65dsubtR");
+/// assert_eq!(wallet.get_address(New).to_string(), "miNG7dJTzJqNbFS19svRdTCisC65dsubtR");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "pkh([c55b303f/44'/1'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)#cfhumdqz");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -273,16 +267,17 @@ impl<K: DerivableKey<Legacy>> DescriptorTemplate for Bip44Public<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip49;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip49(key.clone(), KeychainKind::External),
 ///     Some(Bip49(key, KeychainKind::Internal)),
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "2N4zkWAoGdUv4NXhSsU8DvS5MB36T8nKHEB");
+/// assert_eq!(wallet.get_address(New).to_string(), "2N4zkWAoGdUv4NXhSsU8DvS5MB36T8nKHEB");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "sh(wpkh([c55b303f/49'/1'/0']tpubDDYr4kdnZgjjShzYNjZUZXUUtpXaofdkMaipyS8ThEh45qFmhT4hKYways7UXmg6V7het1QiFo9kf4kYUXyDvV4rHEyvSpys9pjCB3pukxi/0/*))#s9vxlc8e");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -309,9 +304,10 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip49Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip49Public(key.clone(), fingerprint, KeychainKind::External),
@@ -319,7 +315,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49<K> {
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
+/// assert_eq!(wallet.get_address(New).to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "sh(wpkh([c55b303f/49'/1'/0']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))#3tka9g0q");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -346,16 +342,17 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip49Public<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip84;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip84(key.clone(), KeychainKind::External),
 ///     Some(Bip84(key, KeychainKind::Internal)),
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "tb1qhl85z42h7r4su5u37rvvw0gk8j2t3n9y7zsg4n");
+/// assert_eq!(wallet.get_address(New).to_string(), "tb1qhl85z42h7r4su5u37rvvw0gk8j2t3n9y7zsg4n");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "wpkh([c55b303f/84'/1'/0']tpubDDc5mum24DekpNw92t6fHGp8Gr2JjF9J7i4TZBtN6Vp8xpAULG5CFaKsfugWa5imhrQQUZKXe261asP5koDHo5bs3qNTmf3U3o4v9SaB8gg/0/*)#6kfecsmr");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -382,9 +379,10 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip84Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip84Public(key.clone(), fingerprint, KeychainKind::External),
@@ -392,7 +390,7 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84<K> {
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "tb1qedg9fdlf8cnnqfd5mks6uz5w4kgpk2pr6y4qc7");
+/// assert_eq!(wallet.get_address(New).to_string(), "tb1qedg9fdlf8cnnqfd5mks6uz5w4kgpk2pr6y4qc7");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "wpkh([c55b303f/84'/1'/0']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)#dhu402yv");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -419,16 +417,17 @@ impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for Bip84Public<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip86;
 ///
-/// let key = bitcoin::bip32::Xpriv::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
+/// let key = bitcoin::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip86(key.clone(), KeychainKind::External),
 ///     Some(Bip86(key, KeychainKind::Internal)),
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "tb1p5unlj09djx8xsjwe97269kqtxqpwpu2epeskgqjfk4lnf69v4tnqpp35qu");
+/// assert_eq!(wallet.get_address(New).to_string(), "tb1p5unlj09djx8xsjwe97269kqtxqpwpu2epeskgqjfk4lnf69v4tnqpp35qu");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "tr([c55b303f/86'/1'/0']tpubDCiHofpEs47kx358bPdJmTZHmCDqQ8qw32upCSxHrSEdeeBs2T5Mq6QMB2ukeMqhNBiyhosBvJErteVhfURPGXPv3qLJPw5MVpHUewsbP2m/0/*)#dkgvr5hm");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -455,9 +454,10 @@ impl<K: DerivableKey<Tap>> DescriptorTemplate for Bip86<K> {
 /// # use std::str::FromStr;
 /// # use bdk::bitcoin::{PrivateKey, Network};
 /// # use bdk::{Wallet,  KeychainKind};
+/// # use bdk::wallet::AddressIndex::New;
 /// use bdk::template::Bip86Public;
 ///
-/// let key = bitcoin::bip32::Xpub::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
+/// let key = bitcoin::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
 /// let fingerprint = bitcoin::bip32::Fingerprint::from_str("c55b303f")?;
 /// let mut wallet = Wallet::new_no_persist(
 ///     Bip86Public(key.clone(), fingerprint, KeychainKind::External),
@@ -465,7 +465,7 @@ impl<K: DerivableKey<Tap>> DescriptorTemplate for Bip86<K> {
 ///     Network::Testnet,
 /// )?;
 ///
-/// assert_eq!(wallet.next_unused_address(KeychainKind::External)?.to_string(), "tb1pwjp9f2k5n0xq73ecuu0c5njvgqr3vkh7yaylmpqvsuuaafymh0msvcmh37");
+/// assert_eq!(wallet.get_address(New).to_string(), "tb1pwjp9f2k5n0xq73ecuu0c5njvgqr3vkh7yaylmpqvsuuaafymh0msvcmh37");
 /// assert_eq!(wallet.public_descriptor(KeychainKind::External).unwrap().to_string(), "tr([c55b303f/86'/1'/0']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)#2p65srku");
 /// # Ok::<_, Box<dyn std::error::Error>>(())
 /// ```
@@ -567,7 +567,7 @@ mod test {
    fn test_bip44_template_cointype() {
        use bitcoin::bip32::ChildNumber::{self, Hardened};

-        let xprvkey = bitcoin::bip32::Xpriv::from_str("xprv9s21ZrQH143K2fpbqApQL69a4oKdGVnVN52R82Ft7d1pSqgKmajF62acJo3aMszZb6qQ22QsVECSFxvf9uyxFUvFYQMq3QbtwtRSMjLAhMf").unwrap();
+        let xprvkey = bitcoin::bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K2fpbqApQL69a4oKdGVnVN52R82Ft7d1pSqgKmajF62acJo3aMszZb6qQ22QsVECSFxvf9uyxFUvFYQMq3QbtwtRSMjLAhMf").unwrap();
        assert_eq!(Network::Bitcoin, xprvkey.network);
        let xdesc = Bip44(xprvkey, KeychainKind::Internal)
            .build(Network::Bitcoin)
@@ -581,7 +581,7 @@ mod test {
            assert_matches!(coin_type, Hardened { index: 0 });
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        assert_eq!(generated_xprv.valid_networks, any_network());
        assert_eq!(generated_xprv.to_string(), "xprv9s21ZrQH143K4Xr1cJyqTvuL2FWR8eicgY9boWqMBv8MDVUZ65AXHnzBrK1nyomu6wdcabRgmGTaAKawvhAno1V5FowGpTLVx3jxzE5uk3Q");
--- a/crates/bdk/src/psbt/mod.rs
+++ b/crates/bdk/src/psbt/mod.rs
@@ -9,12 +9,11 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.

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

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

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

    /// The transaction's fee rate. This value will only be accurate if calculated AFTER the
-    /// `Psbt` is finalized and all witness/signature data is added to the
+    /// `PartiallySignedTransaction` is finalized and all witness/signature data is added to the
    /// transaction.
    /// If the PSBT is missing a TxOut for an input returns None.
    fn fee_rate(&self) -> Option<FeeRate>;
@@ -54,13 +53,8 @@ impl PsbtUtils for Psbt {
        let utxos: Option<Vec<TxOut>> = (0..tx.input.len()).map(|i| self.get_utxo_for(i)).collect();

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

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

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

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

 use serde::{Deserialize, Serialize};

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

+/// Fee rate
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
+// Internally stored as satoshi/vbyte
+pub struct FeeRate(f32);
+
+impl FeeRate {
+    /// Create a new instance checking the value provided
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    fn new_checked(value: f32) -> Self {
+        assert!(value.is_normal() || value == 0.0);
+        assert!(value.is_sign_positive());
+
+        FeeRate(value)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in sats/kwu
+    pub fn from_sat_per_kwu(sat_per_kwu: f32) -> Self {
+        FeeRate::new_checked(sat_per_kwu / 250.0_f32)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in sats/kvb
+    pub fn from_sat_per_kvb(sat_per_kvb: f32) -> Self {
+        FeeRate::new_checked(sat_per_kvb / 1000.0_f32)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in btc/kvbytes
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    pub fn from_btc_per_kvb(btc_per_kvb: f32) -> Self {
+        FeeRate::new_checked(btc_per_kvb * 1e5)
+    }
+
+    /// Create a new instance of [`FeeRate`] given a float fee rate in satoshi/vbyte
+    ///
+    /// ## Panics
+    ///
+    /// Panics if the value is not [normal](https://doc.rust-lang.org/std/primitive.f32.html#method.is_normal) (except if it's a positive zero) or negative.
+    pub fn from_sat_per_vb(sat_per_vb: f32) -> Self {
+        FeeRate::new_checked(sat_per_vb)
+    }
+
+    /// Create a new [`FeeRate`] with the default min relay fee value
+    pub const fn default_min_relay_fee() -> Self {
+        FeeRate(1.0)
+    }
+
+    /// Calculate fee rate from `fee` and weight units (`wu`).
+    pub fn from_wu(fee: u64, wu: Weight) -> FeeRate {
+        Self::from_vb(fee, wu.to_vbytes_ceil() as usize)
+    }
+
+    /// Calculate fee rate from `fee` and `vbytes`.
+    pub fn from_vb(fee: u64, vbytes: usize) -> FeeRate {
+        let rate = fee as f32 / vbytes as f32;
+        Self::from_sat_per_vb(rate)
+    }
+
+    /// Return the value as satoshi/vbyte
+    pub fn as_sat_per_vb(&self) -> f32 {
+        self.0
+    }
+
+    /// Return the value as satoshi/kwu
+    pub fn sat_per_kwu(&self) -> f32 {
+        self.0 * 250.0_f32
+    }
+
+    /// Calculate absolute fee in Satoshis using size in weight units.
+    pub fn fee_wu(&self, wu: Weight) -> u64 {
+        self.fee_vb(wu.to_vbytes_ceil() as usize)
+    }
+
+    /// Calculate absolute fee in Satoshis using size in virtual bytes.
+    pub fn fee_vb(&self, vbytes: usize) -> u64 {
+        (self.as_sat_per_vb() * vbytes as f32).ceil() as u64
+    }
+}
+
+impl Default for FeeRate {
+    fn default() -> Self {
+        FeeRate::default_min_relay_fee()
+    }
+}
+
+impl Sub for FeeRate {
+    type Output = Self;
+
+    fn sub(self, other: FeeRate) -> Self::Output {
+        FeeRate(self.0 - other.0)
+    }
+}
+
+/// Trait implemented by types that can be used to measure weight units.
+pub trait Vbytes {
+    /// Convert weight units to virtual bytes.
+    fn vbytes(self) -> usize;
+}
+
+impl Vbytes for usize {
+    fn vbytes(self) -> usize {
+        // ref: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-size-calculations
+        (self as f32 / 4.0).ceil() as usize
+    }
+}
+
 /// An unspent output owned by a [`Wallet`].
 ///
 /// [`Wallet`]: crate::Wallet
@@ -133,3 +244,73 @@ impl Utxo {
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn can_store_feerate_in_const() {
+        const _MIN_RELAY: FeeRate = FeeRate::default_min_relay_fee();
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_neg_zero() {
+        let _ = FeeRate::from_sat_per_vb(-0.0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_neg_value() {
+        let _ = FeeRate::from_sat_per_vb(-5.0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_nan() {
+        let _ = FeeRate::from_sat_per_vb(f32::NAN);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_feerate_inf() {
+        let _ = FeeRate::from_sat_per_vb(f32::INFINITY);
+    }
+
+    #[test]
+    fn test_valid_feerate_pos_zero() {
+        let _ = FeeRate::from_sat_per_vb(0.0);
+    }
+
+    #[test]
+    fn test_fee_from_btc_per_kvb() {
+        let fee = FeeRate::from_btc_per_kvb(1e-5);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_vbyte() {
+        let fee = FeeRate::from_sat_per_vb(1.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_default_min_relay_fee() {
+        let fee = FeeRate::default_min_relay_fee();
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_kvb() {
+        let fee = FeeRate::from_sat_per_kvb(1000.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_fee_from_sat_per_kwu() {
+        let fee = FeeRate::from_sat_per_kwu(250.0);
+        assert!((fee.as_sat_per_vb() - 1.0).abs() < f32::EPSILON);
+        assert_eq!(fee.sat_per_kwu(), 250.0);
+    }
+}
--- a/crates/bdk/src/wallet/coin_selection.rs
+++ b/crates/bdk/src/wallet/coin_selection.rs
@@ -28,10 +28,11 @@
 //! # use bitcoin::*;
 //! # use bdk::wallet::{self, ChangeSet, coin_selection::*, coin_selection};
 //! # use bdk::wallet::error::CreateTxError;
-//! # use bdk_persist::PersistBackend;
+//! # use bdk_chain::PersistBackend;
 //! # use bdk::*;
 //! # use bdk::wallet::coin_selection::decide_change;
 //! # use anyhow::Error;
+//! # const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4) * 4;
 //! #[derive(Debug)]
 //! struct AlwaysSpendEverything;
 //!
@@ -40,7 +41,7 @@
 //!         &self,
 //!         required_utxos: Vec<WeightedUtxo>,
 //!         optional_utxos: Vec<WeightedUtxo>,
-//!         fee_rate: FeeRate,
+//!         fee_rate: bdk::FeeRate,
 //!         target_amount: u64,
 //!         drain_script: &Script,
 //!     ) -> Result<CoinSelectionResult, coin_selection::Error> {
@@ -52,17 +53,15 @@
 //!             .scan(
 //!                 (&mut selected_amount, &mut additional_weight),
 //!                 |(selected_amount, additional_weight), weighted_utxo| {
-//!                     **selected_amount += weighted_utxo.utxo.txout().value.to_sat();
+//!                     **selected_amount += weighted_utxo.utxo.txout().value;
 //!                     **additional_weight += Weight::from_wu(
-//!                         (TxIn::default().segwit_weight().to_wu()
-//!                             + weighted_utxo.satisfaction_weight as u64)
-//!                             as u64,
+//!                         (TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight) as u64,
 //!                     );
 //!                     Some(weighted_utxo.utxo)
 //!                 },
 //!             )
 //!             .collect::<Vec<_>>();
-//!         let additional_fees = (fee_rate * additional_weight).to_sat();
+//!         let additional_fees = fee_rate.fee_wu(additional_weight);
 //!         let amount_needed_with_fees = additional_fees + target_amount;
 //!         if selected_amount < amount_needed_with_fees {
 //!             return Err(coin_selection::Error::InsufficientFunds {
@@ -102,15 +101,14 @@
 //! ```

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

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

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

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

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

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

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

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

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

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

@@ -743,19 +738,20 @@ mod test {
    use core::str::FromStr;

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

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

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

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

    const FEE_AMOUNT: u64 = 50;

@@ -771,7 +767,7 @@ mod test {
            utxo: Utxo::Local(LocalOutput {
                outpoint,
                txout: TxOut {
-                    value: Amount::from_sat(value),
+                    value,
                    script_pubkey: ScriptBuf::new(),
                },
                keychain: KeychainKind::External,
@@ -835,7 +831,7 @@ mod test {
                    ))
                    .unwrap(),
                    txout: TxOut {
-                        value: Amount::from_sat(rng.gen_range(0..200000000)),
+                        value: rng.gen_range(0..200000000),
                        script_pubkey: ScriptBuf::new(),
                    },
                    keychain: KeychainKind::External,
@@ -866,7 +862,7 @@ mod test {
                    ))
                    .unwrap(),
                    txout: TxOut {
-                        value: Amount::from_sat(utxos_value),
+                        value: utxos_value,
                        script_pubkey: ScriptBuf::new(),
                    },
                    keychain: KeychainKind::External,
@@ -883,7 +879,7 @@ mod test {
        utxos.shuffle(&mut rng);
        utxos[..utxos_picked_len]
            .iter()
-            .map(|u| u.utxo.txout().value.to_sat())
+            .map(|u| u.utxo.txout().value)
            .sum()
    }

@@ -897,7 +893,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -918,7 +914,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -939,7 +935,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -961,7 +957,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -979,7 +975,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1000),
+                FeeRate::from_sat_per_vb(1000.0),
                target_amount,
                &drain_script,
            )
@@ -996,7 +992,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1017,7 +1013,7 @@ mod test {
            .coin_select(
                utxos,
                vec![],
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1038,7 +1034,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1060,7 +1056,7 @@ mod test {
            .coin_select(
                vec![],
                utxos,
-                FeeRate::from_sat_per_vb_unchecked(1),
+                FeeRate::from_sat_per_vb(1.0),
                target_amount,
                &drain_script,
            )
@@ -1072,18 +1068,14 @@ mod test {
    fn test_oldest_first_coin_selection_insufficient_funds_high_fees() {
        let utxos = get_oldest_first_test_utxos();

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

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

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

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

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

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

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

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

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

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

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

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

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

        let drain_script = ScriptBuf::default();

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

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

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

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

        let selection = BranchAndBoundCoinSelection::default().coin_select(
            required,
            optional,
-            FeeRate::from_sat_per_vb_unchecked(10),
+            FeeRate::from_sat_per_vb(10.0),
            500_000,
            &drain_script,
        );
@@ -1495,7 +1490,7 @@ mod test {
        let selection = BranchAndBoundCoinSelection::default().coin_select(
            utxos,
            vec![],
-            FeeRate::from_sat_per_vb_unchecked(10_000),
+            FeeRate::from_sat_per_vb(10_000.0),
            500_000,
            &drain_script,
        );
@@ -1517,7 +1512,7 @@ mod test {
                utxo: Utxo::Local(LocalOutput {
                    outpoint: OutPoint::new(bitcoin::hashes::Hash::hash(txid.as_bytes()), 0),
                    txout: TxOut {
-                        value: Amount::from_sat(value),
+                        value,
                        script_pubkey: ScriptBuf::new(),
                    },
                    keychain: KeychainKind::External,
--- a/crates/bdk/src/wallet/error.rs
+++ b/crates/bdk/src/wallet/error.rs
@@ -14,7 +14,7 @@
 use crate::descriptor::policy::PolicyError;
 use crate::descriptor::DescriptorError;
 use crate::wallet::coin_selection;
-use crate::{descriptor, KeychainKind};
+use crate::{descriptor, FeeRate, KeychainKind};
 use alloc::string::String;
 use bitcoin::{absolute, psbt, OutPoint, Sequence, Txid};
 use core::fmt;
@@ -47,11 +47,11 @@ impl std::error::Error for MiniscriptPsbtError {}
 /// Error returned from [`TxBuilder::finish`]
 ///
 /// [`TxBuilder::finish`]: crate::wallet::tx_builder::TxBuilder::finish
-pub enum CreateTxError {
+pub enum CreateTxError<P> {
    /// There was a problem with the descriptors passed in
    Descriptor(DescriptorError),
-    /// We were unable to load wallet data from or write wallet data to the persistence backend
-    Persist(anyhow::Error),
+    /// We were unable to write wallet data to the persistence backend
+    Persist(P),
    /// There was a problem while extracting and manipulating policies
    Policy(PolicyError),
    /// Spending policy is not compatible with this [`KeychainKind`]
@@ -83,8 +83,8 @@ pub enum CreateTxError {
    },
    /// When bumping a tx the fee rate requested is lower than required
    FeeRateTooLow {
-        /// Required fee rate
-        required: bitcoin::FeeRate,
+        /// Required fee rate (satoshi/vbyte)
+        required: FeeRate,
    },
    /// `manually_selected_only` option is selected but no utxo has been passed
    NoUtxosSelected,
@@ -119,14 +119,17 @@ pub enum CreateTxError {
    MiniscriptPsbt(MiniscriptPsbtError),
 }

-impl fmt::Display for CreateTxError {
+impl<P> fmt::Display for CreateTxError<P>
+where
+    P: fmt::Display,
+{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Descriptor(e) => e.fmt(f),
            Self::Persist(e) => {
                write!(
                    f,
-                    "failed to load wallet data from or write wallet data to persistence backend: {}",
+                    "failed to write wallet data to persistence backend: {}",
                    e
                )
            }
@@ -165,10 +168,8 @@ impl fmt::Display for CreateTxError {
            CreateTxError::FeeRateTooLow { required } => {
                write!(
                    f,
-                    // Note: alternate fmt as sat/vb (ceil) available in bitcoin-0.31
-                    //"Fee rate too low: required {required:#}"
-                    "Fee rate too low: required {} sat/vb",
-                    crate::floating_rate!(required)
+                    "Fee rate too low: required {} sat/vbyte",
+                    required.as_sat_per_vb()
                )
            }
            CreateTxError::NoUtxosSelected => {
@@ -211,38 +212,38 @@ impl fmt::Display for CreateTxError {
    }
 }

-impl From<descriptor::error::Error> for CreateTxError {
+impl<P> From<descriptor::error::Error> for CreateTxError<P> {
    fn from(err: descriptor::error::Error) -> Self {
        CreateTxError::Descriptor(err)
    }
 }

-impl From<PolicyError> for CreateTxError {
+impl<P> From<PolicyError> for CreateTxError<P> {
    fn from(err: PolicyError) -> Self {
        CreateTxError::Policy(err)
    }
 }

-impl From<MiniscriptPsbtError> for CreateTxError {
+impl<P> From<MiniscriptPsbtError> for CreateTxError<P> {
    fn from(err: MiniscriptPsbtError) -> Self {
        CreateTxError::MiniscriptPsbt(err)
    }
 }

-impl From<psbt::Error> for CreateTxError {
+impl<P> From<psbt::Error> for CreateTxError<P> {
    fn from(err: psbt::Error) -> Self {
        CreateTxError::Psbt(err)
    }
 }

-impl From<coin_selection::Error> for CreateTxError {
+impl<P> From<coin_selection::Error> for CreateTxError<P> {
    fn from(err: coin_selection::Error) -> Self {
        CreateTxError::CoinSelection(err)
    }
 }

 #[cfg(feature = "std")]
-impl std::error::Error for CreateTxError {}
+impl<P: core::fmt::Display + core::fmt::Debug> std::error::Error for CreateTxError<P> {}

 #[derive(Debug)]
 /// Error returned from [`Wallet::build_fee_bump`]
--- a/crates/bdk/src/wallet/export.rs
+++ b/crates/bdk/src/wallet/export.rs
@@ -53,9 +53,9 @@
 //! # Ok::<_, Box<dyn std::error::Error>>(())
 //! ```

-use alloc::string::String;
-use core::fmt;
 use core::str::FromStr;
+
+use alloc::string::{String, ToString};
 use serde::{Deserialize, Serialize};

 use miniscript::descriptor::{ShInner, WshInner};
@@ -80,9 +80,9 @@ pub struct FullyNodedExport {
    pub label: String,
 }

-impl fmt::Display for FullyNodedExport {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", serde_json::to_string(self).unwrap())
+impl ToString for FullyNodedExport {
+    fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap()
    }
 }

@@ -110,8 +110,8 @@ impl FullyNodedExport {
    ///
    /// If the database is empty or `include_blockheight` is false, the `blockheight` field
    /// returned will be `0`.
-    pub fn export_wallet(
-        wallet: &Wallet,
+    pub fn export_wallet<D>(
+        wallet: &Wallet<D>,
        label: &str,
        include_blockheight: bool,
    ) -> Result<Self, &'static str> {
@@ -214,10 +214,9 @@ impl FullyNodedExport {
 mod test {
    use core::str::FromStr;

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

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

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

 use hwi::error::Error;
 use hwi::types::{HWIChain, HWIDevice};
@@ -87,7 +87,7 @@ impl SignerCommon for HWISigner {
 impl TransactionSigner for HWISigner {
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut PartiallySignedTransaction,
        _sign_options: &crate::SignOptions,
        _secp: &crate::wallet::utils::SecpCtx,
    ) -> Result<(), SignerError> {
--- a/crates/bdk/src/wallet/mod.rs
+++ b/crates/bdk/src/wallet/mod.rs
--- a/crates/bdk/src/wallet/signer.rs
+++ b/crates/bdk/src/wallet/signer.rs
@@ -19,12 +19,13 @@
 //! # use core::str::FromStr;
 //! # use bitcoin::secp256k1::{Secp256k1, All};
 //! # use bitcoin::*;
+//! # use bitcoin::psbt;
 //! # use bdk::signer::*;
 //! # use bdk::*;
 //! # #[derive(Debug)]
 //! # struct CustomHSM;
 //! # impl CustomHSM {
-//! #     fn hsm_sign_input(&self, _psbt: &mut Psbt, _input: usize) -> Result<(), SignerError> {
+//! #     fn hsm_sign_input(&self, _psbt: &mut psbt::PartiallySignedTransaction, _input: usize) -> Result<(), SignerError> {
 //! #         Ok(())
 //! #     }
 //! #     fn connect() -> Self {
@@ -54,7 +55,7 @@
 //! impl InputSigner for CustomSigner {
 //!     fn sign_input(
 //!         &self,
-//!         psbt: &mut Psbt,
+//!         psbt: &mut psbt::PartiallySignedTransaction,
 //!         input_index: usize,
 //!         _sign_options: &SignOptions,
 //!         _secp: &Secp256k1<All>,
@@ -86,13 +87,13 @@ use core::cmp::Ordering;
 use core::fmt;
 use core::ops::{Bound::Included, Deref};

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

 use miniscript::descriptor::{
    Descriptor, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey,
@@ -263,7 +264,7 @@ pub trait InputSigner: SignerCommon {
    /// Sign a single psbt input
    fn sign_input(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        input_index: usize,
        sign_options: &SignOptions,
        secp: &SecpCtx,
@@ -278,7 +279,7 @@ pub trait TransactionSigner: SignerCommon {
    /// Sign all the inputs of the psbt
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        sign_options: &SignOptions,
        secp: &SecpCtx,
    ) -> Result<(), SignerError>;
@@ -287,7 +288,7 @@ pub trait TransactionSigner: SignerCommon {
 impl<T: InputSigner> TransactionSigner for T {
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut psbt::PartiallySignedTransaction,
        sign_options: &SignOptions,
        secp: &SecpCtx,
    ) -> Result<(), SignerError> {
@@ -299,7 +300,7 @@ impl<T: InputSigner> TransactionSigner for T {
    }
 }

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

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

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

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

-    /// Whether to remove taproot specific fields from the PSBT on finalization.
-    ///
-    /// For inputs this includes the taproot internal key, merkle root, and individual
-    /// scripts and signatures. For both inputs and outputs it includes key origin info.
-    ///
-    /// Defaults to `true` which will remove all of the above mentioned fields when finalizing.
-    ///
-    /// See [`BIP371`](https://github.com/bitcoin/bips/blob/master/bip-0371.mediawiki) for details.
-    pub remove_taproot_extras: bool,
-
    /// Whether to try finalizing the PSBT after the inputs are signed.
    ///
    /// Defaults to `true` which will try finalizing PSBT after inputs are signed.
@@ -836,7 +827,6 @@ impl Default for SignOptions {
            assume_height: None,
            allow_all_sighashes: false,
            remove_partial_sigs: true,
-            remove_taproot_extras: true,
            try_finalize: true,
            tap_leaves_options: TapLeavesOptions::default(),
            sign_with_tap_internal_key: true,
@@ -851,7 +841,7 @@ pub(crate) trait ComputeSighash {
    type SighashType;

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

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

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

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

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

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

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

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

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

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

 /// Context in which the [`TxBuilder`] is valid
 pub trait TxBuilderContext: core::fmt::Debug + Default + Clone {}
@@ -84,7 +87,7 @@ impl TxBuilderContext for BumpFee {}
 /// # use core::str::FromStr;
 /// # use bdk::wallet::ChangeSet;
 /// # use bdk::wallet::error::CreateTxError;
-/// # use bdk_persist::PersistBackend;
+/// # use bdk_chain::PersistBackend;
 /// # use anyhow::Error;
 /// # let mut wallet = doctest_wallet!();
 /// # let addr1 = Address::from_str("2N4eQYCbKUHCCTUjBJeHcJp9ok6J2GZsTDt").unwrap().assume_checked();
@@ -123,8 +126,8 @@ impl TxBuilderContext for BumpFee {}
 /// [`finish`]: Self::finish
 /// [`coin_selection`]: Self::coin_selection
 #[derive(Debug)]
-pub struct TxBuilder<'a, Cs, Ctx> {
-    pub(crate) wallet: Rc<RefCell<&'a mut Wallet>>,
+pub struct TxBuilder<'a, D, Cs, Ctx> {
+    pub(crate) wallet: Rc<RefCell<&'a mut Wallet<D>>>,
    pub(crate) params: TxParams,
    pub(crate) coin_selection: Cs,
    pub(crate) phantom: PhantomData<Ctx>,
@@ -160,7 +163,7 @@ pub(crate) struct TxParams {
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct PreviousFee {
    pub absolute: u64,
-    pub rate: FeeRate,
+    pub rate: f32,
 }

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

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

-impl<'a, Cs: Clone, Ctx> Clone for TxBuilder<'a, Cs, Ctx> {
+impl<'a, D, Cs: Clone, Ctx> Clone for TxBuilder<'a, D, Cs, Ctx> {
    fn clone(&self) -> Self {
        TxBuilder {
            wallet: self.wallet.clone(),
@@ -187,13 +190,15 @@ impl<'a, Cs: Clone, Ctx> Clone for TxBuilder<'a, Cs, Ctx> {
 }

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

            for utxo in utxos {
                let descriptor = wallet.get_descriptor_for_keychain(utxo.keychain);
-                let satisfaction_weight = descriptor.max_weight_to_satisfy().unwrap();
+                #[allow(deprecated)]
+                let satisfaction_weight = descriptor.max_satisfaction_weight().unwrap();
                self.params.utxos.push(WeightedUtxo {
                    satisfaction_weight,
                    utxo: Utxo::Local(utxo),
@@ -354,9 +360,9 @@ impl<'a, Cs, Ctx> TxBuilder<'a, Cs, Ctx> {
    /// causing you to pay a fee that is too high. The party who is broadcasting the transaction can
    /// of course check the real input weight matches the expected weight prior to broadcasting.
    ///
-    /// To guarantee the `max_weight_to_satisfy` is correct, you can require the party providing the
+    /// To guarantee the `satisfaction_weight` is correct, you can require the party providing the
    /// `psbt_input` provide a miniscript descriptor for the input so you can check it against the
-    /// `script_pubkey` and then ask it for the [`max_weight_to_satisfy`].
+    /// `script_pubkey` and then ask it for the [`max_satisfaction_weight`].
    ///
    /// This is an **EXPERIMENTAL** feature, API and other major changes are expected.
    ///
@@ -377,7 +383,7 @@ impl<'a, Cs, Ctx> TxBuilder<'a, Cs, Ctx> {
    ///
    /// [`only_witness_utxo`]: Self::only_witness_utxo
    /// [`finish`]: Self::finish
-    /// [`max_weight_to_satisfy`]: miniscript::Descriptor::max_weight_to_satisfy
+    /// [`max_satisfaction_weight`]: miniscript::Descriptor::max_satisfaction_weight
    pub fn add_foreign_utxo(
        &mut self,
        outpoint: OutPoint,
@@ -559,7 +565,7 @@ impl<'a, Cs, Ctx> TxBuilder<'a, Cs, Ctx> {
    pub fn coin_selection<P: CoinSelectionAlgorithm>(
        self,
        coin_selection: P,
-    ) -> TxBuilder<'a, P, Ctx> {
+    ) -> TxBuilder<'a, D, P, Ctx> {
        TxBuilder {
            wallet: self.wallet,
            params: self.params,
@@ -614,13 +620,16 @@ impl<'a, Cs, Ctx> TxBuilder<'a, Cs, Ctx> {
    }
 }

-impl<'a, Cs: CoinSelectionAlgorithm, Ctx> TxBuilder<'a, Cs, Ctx> {
+impl<'a, D, Cs: CoinSelectionAlgorithm, Ctx> TxBuilder<'a, D, Cs, Ctx> {
    /// Finish building the transaction.
    ///
    /// Returns a new [`Psbt`] per [`BIP174`].
    ///
    /// [`BIP174`]: https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
-    pub fn finish(self) -> Result<Psbt, CreateTxError> {
+    pub fn finish(self) -> Result<Psbt, CreateTxError<D::WriteError>>
+    where
+        D: PersistBackend<ChangeSet>,
+    {
        self.wallet
            .borrow_mut()
            .create_tx(self.coin_selection, self.params)
@@ -711,7 +720,7 @@ impl fmt::Display for AllowShrinkingError {
 #[cfg(feature = "std")]
 impl std::error::Error for AllowShrinkingError {}

-impl<'a, Cs: CoinSelectionAlgorithm> TxBuilder<'a, Cs, CreateTx> {
+impl<'a, D, Cs: CoinSelectionAlgorithm> TxBuilder<'a, D, Cs, CreateTx> {
    /// Replace the recipients already added with a new list
    pub fn set_recipients(&mut self, recipients: Vec<(ScriptBuf, u64)>) -> &mut Self {
        self.params.recipients = recipients;
@@ -758,7 +767,7 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilder<'a, Cs, CreateTx> {
    /// # use bdk::wallet::ChangeSet;
    /// # use bdk::wallet::error::CreateTxError;
    /// # use bdk::wallet::tx_builder::CreateTx;
-    /// # use bdk_persist::PersistBackend;
+    /// # use bdk_chain::PersistBackend;
    /// # use anyhow::Error;
    /// # let to_address =
    /// Address::from_str("2N4eQYCbKUHCCTUjBJeHcJp9ok6J2GZsTDt")
@@ -772,7 +781,7 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilder<'a, Cs, CreateTx> {
    ///     .drain_wallet()
    ///     // Send the excess (which is all the coins minus the fee) to this address.
    ///     .drain_to(to_address.script_pubkey())
-    ///     .fee_rate(FeeRate::from_sat_per_vb(5).expect("valid feerate"))
+    ///     .fee_rate(bdk::FeeRate::from_sat_per_vb(5.0))
    ///     .enable_rbf();
    /// let psbt = tx_builder.finish()?;
    /// # Ok::<(), anyhow::Error>(())
@@ -789,7 +798,7 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilder<'a, Cs, CreateTx> {
 }

 // methods supported only by bump_fee
-impl<'a> TxBuilder<'a, DefaultCoinSelectionAlgorithm, BumpFee> {
+impl<'a, D> TxBuilder<'a, D, DefaultCoinSelectionAlgorithm, BumpFee> {
    /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this
    /// `script_pubkey` in order to bump the transaction fee. Without specifying this the wallet
    /// will attempt to find a change output to shrink instead.
@@ -923,8 +932,7 @@ mod test {

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

    use super::*;

@@ -995,7 +1003,7 @@ mod test {
            .unwrap()
        );

-        assert_eq!(tx.output[0].value.to_sat(), 800);
+        assert_eq!(tx.output[0].value, 800);
        assert_eq!(tx.output[1].script_pubkey, ScriptBuf::from(vec![0xAA]));
        assert_eq!(
            tx.output[2].script_pubkey,
@@ -1012,7 +1020,7 @@ mod test {
                    txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(),
                    vout: 0,
                },
-                txout: TxOut::NULL,
+                txout: Default::default(),
                keychain: KeychainKind::External,
                is_spent: false,
                confirmation_time: ConfirmationTime::Unconfirmed { last_seen: 0 },
@@ -1023,7 +1031,7 @@ mod test {
                    txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(),
                    vout: 1,
                },
-                txout: TxOut::NULL,
+                txout: Default::default(),
                keychain: KeychainKind::Internal,
                is_spent: false,
                confirmation_time: ConfirmationTime::Confirmed {
--- a/crates/bdk/src/wallet/utils.rs
+++ b/crates/bdk/src/wallet/utils.rs
@@ -138,7 +138,7 @@ mod test {
            .require_network(Network::Bitcoin)
            .unwrap()
            .script_pubkey();
-        assert!(script_p2wpkh.is_p2wpkh());
+        assert!(script_p2wpkh.is_v0_p2wpkh());
        assert!(293.is_dust(&script_p2wpkh));
        assert!(!294.is_dust(&script_p2wpkh));
    }
--- a/crates/bdk/tests/common.rs
+++ b/crates/bdk/tests/common.rs
@@ -1,13 +1,10 @@
 #![allow(unused)]

-use bdk::{KeychainKind, LocalOutput, Wallet};
+use bdk::{wallet::AddressIndex, KeychainKind, LocalOutput, Wallet};
 use bdk_chain::indexed_tx_graph::Indexer;
 use bdk_chain::{BlockId, ConfirmationTime};
 use bitcoin::hashes::Hash;
-use bitcoin::{
-    transaction, Address, Amount, BlockHash, FeeRate, Network, OutPoint, Transaction, TxIn, TxOut,
-    Txid,
-};
+use bitcoin::{Address, BlockHash, Network, OutPoint, Transaction, TxIn, TxOut, Txid};
 use std::str::FromStr;

 // Return a fake wallet that appears to be funded for testing.
@@ -20,14 +17,14 @@ pub fn get_funded_wallet_with_change(
    change: Option<&str>,
 ) -> (Wallet, bitcoin::Txid) {
    let mut wallet = Wallet::new_no_persist(descriptor, change, Network::Regtest).unwrap();
-    let change_address = wallet.peek_address(KeychainKind::External, 0).address;
+    let change_address = wallet.get_address(AddressIndex::New).address;
    let sendto_address = Address::from_str("bcrt1q3qtze4ys45tgdvguj66zrk4fu6hq3a3v9pfly5")
        .expect("address")
        .require_network(Network::Regtest)
        .unwrap();

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

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

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

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

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

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

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

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

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

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

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

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

    wpkh_psbt.inputs[0].witness_utxo = None;
@@ -143,10 +146,10 @@ fn test_psbt_fee_rate_with_missing_txout() {
    assert!(wpkh_psbt.fee_rate().is_none());

    let (mut pkh_wallet,  _) = get_funded_wallet("pkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
-    let addr = pkh_wallet.peek_address(KeychainKind::External, 0);
+    let addr = pkh_wallet.get_address(New);
    let mut builder = pkh_wallet.build_tx();
    builder.drain_to(addr.script_pubkey()).drain_wallet();
-    builder.fee_rate(expected_fee_rate);
+    builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
    let mut pkh_psbt = builder.finish().unwrap();

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

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

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

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

 [features]
--- a/crates/bitcoind_rpc/tests/test_emitter.rs
+++ b/crates/bitcoind_rpc/tests/test_emitter.rs
@@ -2,14 +2,160 @@ use std::collections::{BTreeMap, BTreeSet};

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

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

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

-    // See if the emitter outputs the right blocks.
+    // see if the emitter outputs the right blocks
    println!("first sync:");
    while let Some(emission) = emitter.next_block()? {
        let height = emission.block_height();
@@ -47,26 +188,26 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
        );

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

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

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

-    // See if the emitter outputs the right blocks.
+    // see if the emitter outputs the right blocks
    println!("after reorg:");
    let mut exp_height = exp_hashes.len() - reorged_blocks.len();
    while let Some(emission) = emitter.next_block()? {
@@ -92,7 +233,10 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
        );

        assert_eq!(
-            local_chain.apply_update(emission.checkpoint,)?,
+            local_chain.apply_update(local_chain::Update {
+                tip: emission.checkpoint,
+                introduce_older_blocks: false,
+            })?,
            if exp_height == exp_hashes.len() - reorged_blocks.len() {
                core::iter::once((height, Some(hash)))
                    .chain((height + 1..exp_hashes.len() as u32).map(|h| (h, None)))
@@ -107,15 +251,12 @@ pub fn test_sync_local_chain() -> anyhow::Result<()> {
    }

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

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

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

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

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

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

    while let Some(emission) = emitter.next_block()? {
        let height = emission.block_height();
-        let _ = chain.apply_update(emission.checkpoint)?;
+        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);
        assert!(indexed_additions.is_empty());
    }
@@ -171,7 +306,7 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
    let exp_txids = {
        let mut txids = BTreeSet::new();
        for _ in 0..3 {
-            txids.insert(env.rpc_client().send_to_address(
+            txids.insert(env.client.send_to_address(
                &addr_0,
                Amount::from_sat(10_000),
                None,
@@ -207,7 +342,7 @@ fn test_into_tx_graph() -> anyhow::Result<()> {

    // mine a block that confirms the 3 txs
    let exp_block_hash = env.mine_blocks(1, None)?[0];
-    let exp_block_height = env.rpc_client().get_block_info(&exp_block_hash)?.height as u32;
+    let exp_block_height = env.client.get_block_info(&exp_block_hash)?.height as u32;
    let exp_anchors = exp_txids
        .iter()
        .map({
@@ -223,7 +358,10 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
    {
        let emission = emitter.next_block()?.expect("must get mined block");
        let height = emission.block_height();
-        let _ = chain.apply_update(emission.checkpoint)?;
+        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);
        assert!(indexed_additions.graph.txs.is_empty());
        assert!(indexed_additions.graph.txouts.is_empty());
@@ -248,10 +386,10 @@ fn ensure_block_emitted_after_reorg_is_at_reorg_height() -> anyhow::Result<()> {

    let env = TestEnv::new()?;
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        EMITTER_START_HEIGHT as _,
    );
@@ -282,7 +420,8 @@ fn process_block(
    block: Block,
    block_height: u32,
 ) -> anyhow::Result<()> {
-    recv_chain.apply_update(CheckPoint::from_header(&block.header, block_height))?;
+    recv_chain
+        .apply_update(CheckPoint::from_header(&block.header, block_height).into_update(false))?;
    let _ = recv_graph.apply_block(block, block_height);
    Ok(())
 }
@@ -324,24 +463,21 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {

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

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

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

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

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

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

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

@@ -480,19 +613,16 @@ fn mempool_re_emits_if_tx_introduction_height_not_reached() -> anyhow::Result<()

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

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

@@ -568,19 +698,16 @@ fn mempool_during_reorg() -> anyhow::Result<()> {

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

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

    // introduce mempool tx at each block extension
@@ -598,7 +725,7 @@ fn mempool_during_reorg() -> anyhow::Result<()> {
            .into_iter()
            .map(|(tx, _)| tx.txid())
            .collect::<BTreeSet<_>>(),
-        env.rpc_client()
+        env.client
            .get_raw_mempool()?
            .into_iter()
            .collect::<BTreeSet<_>>(),
@@ -617,7 +744,7 @@ fn mempool_during_reorg() -> anyhow::Result<()> {
        // emission.
        // TODO: How can have have reorg logic in `TestEnv` NOT blacklast old blocks first?
        let tx_introductions = dbg!(env
-            .rpc_client()
+            .client
            .get_raw_mempool_verbose()?
            .into_iter()
            .map(|(txid, entry)| (txid, entry.height as usize))
@@ -694,10 +821,10 @@ fn no_agreement_point() -> anyhow::Result<()> {

    // start height is 99
    let mut emitter = Emitter::new(
-        env.rpc_client(),
+        &env.client,
        CheckPoint::new(BlockId {
            height: 0,
-            hash: env.rpc_client().get_block_hash(0)?,
+            hash: env.client.get_block_hash(0)?,
        }),
        (PREMINE_COUNT - 2) as u32,
    );
@@ -715,12 +842,12 @@ fn no_agreement_point() -> anyhow::Result<()> {
    let block_hash_100a = block_header_100a.block_hash();

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

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

    // mine new blocks 99b, 100b, 101b
    env.mine_blocks(3, None)?;
--- a/crates/chain/Cargo.toml
+++ b/crates/chain/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_chain"
-version = "0.13.0"
+version = "0.11.0"
 edition = "2021"
 rust-version = "1.63"
 homepage = "https://bitcoindevkit.org"
@@ -14,16 +14,15 @@ readme = "README.md"

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

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

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

 [features]
 default = ["std"]
--- a/crates/chain/src/keychain/txout_index.rs
+++ b/crates/chain/src/keychain/txout_index.rs
@@ -268,14 +268,15 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
        self.inner.unmark_used(&(keychain, index))
    }

-    /// Computes the total value transfer effect `tx` has on the script pubkeys belonging to the
-    /// keychains in `range`. Value is *sent* when a script pubkey in the `range` is on an input and
-    /// *received* when it is on an output. For `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.
-    pub fn sent_and_received(&self, tx: &Transaction, range: impl RangeBounds<K>) -> (u64, u64) {
-        self.inner
-            .sent_and_received(tx, Self::map_to_inner_bounds(range))
+    /// 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
@@ -285,8 +286,8 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
    /// This calls [`SpkTxOutIndex::net_value`] internally.
    ///
    /// [`sent_and_received`]: Self::sent_and_received
-    pub fn net_value(&self, tx: &Transaction, range: impl RangeBounds<K>) -> i64 {
-        self.inner.net_value(tx, Self::map_to_inner_bounds(range))
+    pub fn net_value(&self, tx: &Transaction) -> i64 {
+        self.inner.net_value(tx)
    }
 }

@@ -389,32 +390,24 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
            .collect()
    }

-    /// Iterate over revealed spks of keychains in `range`
-    pub fn revealed_spks(
-        &self,
-        range: impl RangeBounds<K>,
-    ) -> impl DoubleEndedIterator<Item = (&K, u32, &Script)> + Clone {
-        self.keychains.range(range).flat_map(|(keychain, _)| {
-            let start = Bound::Included((keychain.clone(), u32::MIN));
-            let end = match self.last_revealed.get(keychain) {
-                Some(last_revealed) => Bound::Included((keychain.clone(), *last_revealed)),
-                None => Bound::Excluded((keychain.clone(), u32::MIN)),
-            };
-
-            self.inner
-                .all_spks()
-                .range((start, end))
-                .map(|((keychain, i), spk)| (keychain, *i, spk.as_script()))
+    /// 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))
        })
    }

    /// Iterate over revealed spks of the given `keychain`.
-    pub fn revealed_keychain_spks<'a>(
-        &'a self,
-        keychain: &'a K,
-    ) -> impl DoubleEndedIterator<Item = (u32, &Script)> + 'a {
-        self.revealed_spks(keychain..=keychain)
-            .map(|(_, i, spk)| (i, spk))
+    pub fn revealed_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
+            .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.
@@ -624,40 +617,38 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
        }
    }

-    /// Iterate over all [`OutPoint`]s that have `TxOut`s with script pubkeys derived from
+    /// Iterate over all [`OutPoint`]s that point to `TxOut`s with script pubkeys derived from
    /// `keychain`.
-    pub fn keychain_outpoints<'a>(
-        &'a self,
-        keychain: &'a K,
-    ) -> impl DoubleEndedIterator<Item = (u32, OutPoint)> + 'a {
-        self.keychain_outpoints_in_range(keychain..=keychain)
-            .map(move |(_, i, op)| (i, op))
+    ///
+    /// 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, ..)
    }

-    /// Iterate over [`OutPoint`]s that have script pubkeys derived from keychains in `range`.
-    pub fn keychain_outpoints_in_range<'a>(
-        &'a self,
-        range: impl RangeBounds<K> + 'a,
-    ) -> impl DoubleEndedIterator<Item = (&'a K, u32, OutPoint)> + 'a {
-        let bounds = Self::map_to_inner_bounds(range);
+    /// 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(
+        &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,
+        };
        self.inner
-            .outputs_in_range(bounds)
-            .map(move |((keychain, i), op)| (keychain, *i, op))
-    }
-
-    fn map_to_inner_bounds(bound: impl RangeBounds<K>) -> impl RangeBounds<(K, u32)> {
-        let start = match bound.start_bound() {
-            Bound::Included(keychain) => Bound::Included((keychain.clone(), u32::MIN)),
-            Bound::Excluded(keychain) => Bound::Excluded((keychain.clone(), u32::MAX)),
-            Bound::Unbounded => Bound::Unbounded,
-        };
-        let end = match bound.end_bound() {
-            Bound::Included(keychain) => Bound::Included((keychain.clone(), u32::MAX)),
-            Bound::Excluded(keychain) => Bound::Excluded((keychain.clone(), u32::MIN)),
-            Bound::Unbounded => Bound::Unbounded,
-        };
-
-        (start, end)
+            .outputs_in_range((start, end))
+            .map(|((_, i), op)| (*i, op))
    }

    /// Returns the highest derivation index of the `keychain` where [`KeychainTxOutIndex`] has
--- a/crates/chain/src/lib.rs
+++ b/crates/chain/src/lib.rs
@@ -35,6 +35,8 @@ pub use tx_data_traits::*;
 pub use tx_graph::TxGraph;
 mod chain_oracle;
 pub use chain_oracle::*;
+mod persist;
+pub use persist::*;

 #[doc(hidden)]
 pub mod example_utils;
@@ -49,7 +51,6 @@ pub use descriptor_ext::DescriptorExt;
 mod spk_iter;
 #[cfg(feature = "miniscript")]
 pub use spk_iter::*;
-pub mod spk_client;

 #[allow(unused_imports)]
 #[macro_use]
--- a/crates/chain/src/local_chain.rs
+++ b/crates/chain/src/local_chain.rs
@@ -1,7 +1,6 @@
 //! The [`LocalChain`] is a local implementation of [`ChainOracle`].

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

 use crate::collections::BTreeMap;
 use crate::{BlockId, ChainOracle};
@@ -35,14 +34,6 @@ struct CPInner {
    prev: Option<Arc<CPInner>>,
 }

-impl PartialEq for CheckPoint {
-    fn eq(&self, other: &Self) -> bool {
-        let self_cps = self.iter().map(|cp| cp.block_id());
-        let other_cps = other.iter().map(|cp| cp.block_id());
-        self_cps.eq(other_cps)
-    }
-}
-
 impl CheckPoint {
    /// Construct a new base block at the front of a linked list.
    pub fn new(block: BlockId) -> Self {
@@ -96,6 +87,16 @@ impl CheckPoint {
            .expect("must construct checkpoint")
    }

+    /// Convenience method to convert the [`CheckPoint`] into an [`Update`].
+    ///
+    /// For more information, refer to [`Update`].
+    pub fn into_update(self, introduce_older_blocks: bool) -> Update {
+        Update {
+            tip: self,
+            introduce_older_blocks,
+        }
+    }
+
    /// Puts another checkpoint onto the linked list representing the blockchain.
    ///
    /// Returns an `Err(self)` if the block you are pushing on is not at a greater height that the one you
@@ -147,112 +148,6 @@ impl CheckPoint {
    pub fn iter(&self) -> CheckPointIter {
        self.clone().into_iter()
    }
-
-    /// Get checkpoint at `height`.
-    ///
-    /// Returns `None` if checkpoint at `height` does not exist`.
-    pub fn get(&self, height: u32) -> Option<Self> {
-        self.range(height..=height).next()
-    }
-
-    /// Iterate checkpoints over a height range.
-    ///
-    /// Note that we always iterate checkpoints in reverse height order (iteration starts at tip
-    /// height).
-    pub fn range<R>(&self, range: R) -> impl Iterator<Item = CheckPoint>
-    where
-        R: RangeBounds<u32>,
-    {
-        let start_bound = range.start_bound().cloned();
-        let end_bound = range.end_bound().cloned();
-        self.iter()
-            .skip_while(move |cp| match end_bound {
-                core::ops::Bound::Included(inc_bound) => cp.height() > inc_bound,
-                core::ops::Bound::Excluded(exc_bound) => cp.height() >= exc_bound,
-                core::ops::Bound::Unbounded => false,
-            })
-            .take_while(move |cp| match start_bound {
-                core::ops::Bound::Included(inc_bound) => cp.height() >= inc_bound,
-                core::ops::Bound::Excluded(exc_bound) => cp.height() > exc_bound,
-                core::ops::Bound::Unbounded => true,
-            })
-    }
-
-    /// Inserts `block_id` at its height within the chain.
-    ///
-    /// The effect of `insert` depends on whether a height already exists. If it doesn't the
-    /// `block_id` we inserted and all pre-existing blocks higher than it will be re-inserted after
-    /// it. If the height already existed and has a conflicting block hash then it will be purged
-    /// along with all block followin it. The returned chain will have a tip of the `block_id`
-    /// passed in. Of course, if the `block_id` was already present then this just returns `self`.
-    #[must_use]
-    pub fn insert(self, block_id: BlockId) -> Self {
-        assert_ne!(block_id.height, 0, "cannot insert the genesis block");
-
-        let mut cp = self.clone();
-        let mut tail = vec![];
-        let base = loop {
-            if cp.height() == block_id.height {
-                if cp.hash() == block_id.hash {
-                    return self;
-                }
-                // if we have a conflict we just return the inserted block because the tail is by
-                // implication invalid.
-                tail = vec![];
-                break cp.prev().expect("can't be called on genesis block");
-            }
-
-            if cp.height() < block_id.height {
-                break cp;
-            }
-
-            tail.push(cp.block_id());
-            cp = cp.prev().expect("will break before genesis block");
-        };
-
-        base.extend(core::iter::once(block_id).chain(tail.into_iter().rev()))
-            .expect("tail is in order")
-    }
-
-    /// Apply `changeset` to the checkpoint.
-    fn apply_changeset(mut self, changeset: &ChangeSet) -> Result<CheckPoint, MissingGenesisError> {
-        if let Some(start_height) = changeset.keys().next().cloned() {
-            // changes after point of agreement
-            let mut extension = BTreeMap::default();
-            // point of agreement
-            let mut base: Option<CheckPoint> = None;
-
-            for cp in self.iter() {
-                if cp.height() >= start_height {
-                    extension.insert(cp.height(), cp.hash());
-                } else {
-                    base = Some(cp);
-                    break;
-                }
-            }
-
-            for (&height, &hash) in changeset {
-                match hash {
-                    Some(hash) => {
-                        extension.insert(height, hash);
-                    }
-                    None => {
-                        extension.remove(&height);
-                    }
-                };
-            }
-
-            let new_tip = match base {
-                Some(base) => base
-                    .extend(extension.into_iter().map(BlockId::from))
-                    .expect("extension is strictly greater than base"),
-                None => LocalChain::from_blocks(extension)?.tip(),
-            };
-            self = new_tip;
-        }
-
-        Ok(self)
-    }
 }

 /// Iterates over checkpoints backwards.
@@ -265,7 +160,7 @@ impl Iterator for CheckPointIter {

    fn next(&mut self) -> Option<Self::Item> {
        let current = self.current.clone()?;
-        self.current.clone_from(&current.prev);
+        self.current = current.prev.clone();
        Some(CheckPoint(current))
    }
 }
@@ -281,10 +176,48 @@ impl IntoIterator for CheckPoint {
    }
 }

+/// Used 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
+/// blocks to the original chain.
+///
+/// Block-by-block syncing mechanisms would typically create updates that builds upon the previous
+/// tip. In this case, `introduce_older_blocks` would be `false`.
+///
+/// Script-pubkey based syncing mechanisms may not introduce transactions in a chronological order
+/// so some updates require introducing older blocks (to anchor older transactions). For
+/// script-pubkey based syncing, `introduce_older_blocks` would typically be `true`.
+#[derive(Debug, Clone)]
+pub struct Update {
+    /// The update chain's new tip.
+    pub tip: CheckPoint,
+
+    /// Whether the update allows for introducing older blocks.
+    ///
+    /// Refer to [struct-level documentation] for more.
+    ///
+    /// [struct-level documentation]: Update
+    pub introduce_older_blocks: bool,
+}
+
 /// This is a local implementation of [`ChainOracle`].
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct LocalChain {
    tip: CheckPoint,
+    index: BTreeMap<u32, BlockHash>,
+}
+
+impl PartialEq for LocalChain {
+    fn eq(&self, other: &Self) -> bool {
+        self.index == other.index
+    }
+}
+
+impl From<LocalChain> for BTreeMap<u32, BlockHash> {
+    fn from(value: LocalChain) -> Self {
+        value.index
+    }
 }

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

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

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

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

        Ok(chain)
@@ -347,11 +284,18 @@ impl LocalChain {

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

    /// Constructs a [`LocalChain`] from a [`BTreeMap`] of height to [`BlockHash`].
@@ -364,6 +308,7 @@ impl LocalChain {
        }

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

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

    /// Get the highest checkpoint.
@@ -388,22 +337,36 @@ impl LocalChain {

    /// Applies the given `update` to the chain.
    ///
-    /// The method returns [`ChangeSet`] on success. This represents the changes applied to `self`.
+    /// The method returns [`ChangeSet`] on success. This represents the applied changes to `self`.
    ///
    /// There must be no ambiguity about which of the existing chain's blocks are still valid and
    /// which are now invalid. That is, the new chain must implicitly connect to a definite block in
    /// the existing chain and invalidate the block after it (if it exists) by including a block at
    /// the same height but with a different hash to explicitly exclude it as a connection point.
    ///
+    /// Additionally, an empty chain can be updated with any chain, and a chain with a single block
+    /// can have it's block invalidated by an update chain with a block at the same height but
+    /// different hash.
+    ///
    /// # Errors
    ///
    /// An error will occur if the update does not correctly connect with `self`.
    ///
+    /// Refer to [`Update`] for more about the update struct.
+    ///
    /// [module-level documentation]: crate::local_chain
-    pub fn apply_update(&mut self, update: CheckPoint) -> Result<ChangeSet, CannotConnectError> {
-        let (new_tip, changeset) = merge_chains(self.tip.clone(), update)?;
-        self.tip = new_tip;
-        self._check_changeset_is_applied(&changeset);
+    pub fn apply_update(&mut self, update: Update) -> Result<ChangeSet, CannotConnectError> {
+        let changeset = merge_chains(
+            self.tip.clone(),
+            update.tip.clone(),
+            update.introduce_older_blocks,
+        )?;
+        // `._check_index_is_consistent_with_tip` and `._check_changeset_is_applied` is called in
+        // `.apply_changeset`
+        self.apply_changeset(&changeset)
+            .map_err(|_| CannotConnectError {
+                try_include_height: 0,
+            })?;
        Ok(changeset)
    }

@@ -455,8 +418,11 @@ impl LocalChain {
            conn => Some(conn),
        };

-        let update = CheckPoint::from_block_ids([conn, prev, Some(this)].into_iter().flatten())
-            .expect("block ids must be in order");
+        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)
@@ -495,10 +461,45 @@ impl LocalChain {

    /// Apply the given `changeset`.
    pub fn apply_changeset(&mut self, changeset: &ChangeSet) -> Result<(), MissingGenesisError> {
-        let old_tip = self.tip.clone();
-        let new_tip = old_tip.apply_changeset(changeset)?;
-        self.tip = new_tip;
-        debug_assert!(self._check_changeset_is_applied(changeset));
+        if let Some(start_height) = changeset.keys().next().cloned() {
+            // changes after point of agreement
+            let mut extension = BTreeMap::default();
+            // point of agreement
+            let mut base: Option<CheckPoint> = None;
+
+            for cp in self.iter_checkpoints() {
+                if cp.height() >= start_height {
+                    extension.insert(cp.height(), cp.hash());
+                } else {
+                    base = Some(cp);
+                    break;
+                }
+            }
+
+            for (&height, &hash) in changeset {
+                match hash {
+                    Some(hash) => {
+                        extension.insert(height, hash);
+                    }
+                    None => {
+                        extension.remove(&height);
+                    }
+                };
+            }
+
+            let new_tip = match base {
+                Some(base) => base
+                    .extend(extension.into_iter().map(BlockId::from))
+                    .expect("extension is strictly greater than base"),
+                None => LocalChain::from_blocks(extension)?.tip(),
+            };
+            self.tip = new_tip;
+            self.reindex(start_height);
+
+            debug_assert!(self._check_index_is_consistent_with_tip());
+            debug_assert!(self._check_changeset_is_applied(changeset));
+        }
+
        Ok(())
    }

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

        let mut changeset = ChangeSet::default();
@@ -541,41 +542,33 @@ impl LocalChain {
    /// This will fail with [`MissingGenesisError`] if the caller attempts to disconnect from the
    /// genesis block.
    pub fn disconnect_from(&mut self, block_id: BlockId) -> Result<ChangeSet, MissingGenesisError> {
-        let mut remove_from = Option::<CheckPoint>::None;
-        let mut changeset = ChangeSet::default();
-        for cp in self.tip().iter() {
-            let cp_id = cp.block_id();
-            if cp_id.height < block_id.height {
+        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);
+        for cp in self.iter_checkpoints() {
+            if cp.height() < from {
                break;
            }
-            changeset.insert(cp_id.height, None);
-            if cp_id == block_id {
-                remove_from = Some(cp);
-            }
+            self.index.insert(cp.height(), cp.hash());
        }
-        self.tip = match remove_from.map(|cp| cp.prev()) {
-            // The checkpoint below the earliest checkpoint to remove will be the new tip.
-            Some(Some(new_tip)) => new_tip,
-            // If there is no checkpoint below the earliest checkpoint to remove, it means the
-            // "earliest checkpoint to remove" is the genesis block. We disallow removing the
-            // genesis block.
-            Some(None) => return Err(MissingGenesisError),
-            // If there is nothing to remove, we return an empty changeset.
-            None => return Ok(ChangeSet::default()),
-        };
-        Ok(changeset)
    }

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

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

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

 /// An error which occurs when a [`LocalChain`] is constructed without a genesis checkpoint.
@@ -721,17 +693,14 @@ impl core::fmt::Display for ApplyHeaderError {
 #[cfg(feature = "std")]
 impl std::error::Error for ApplyHeaderError {}

-/// Applies `update_tip` onto `original_tip`.
-///
-/// On success, a tuple is returned `(changeset, can_replace)`. If `can_replace` is true, then the
-/// `update_tip` can replace the `original_tip`.
 fn merge_chains(
    original_tip: CheckPoint,
    update_tip: CheckPoint,
-) -> Result<(CheckPoint, ChangeSet), CannotConnectError> {
+    introduce_older_blocks: bool,
+) -> Result<ChangeSet, CannotConnectError> {
    let mut changeset = ChangeSet::default();
-    let mut orig = original_tip.iter();
-    let mut update = update_tip.iter();
+    let mut orig = original_tip.into_iter();
+    let mut update = update_tip.into_iter();
    let mut curr_orig = None;
    let mut curr_update = None;
    let mut prev_orig: Option<CheckPoint> = None;
@@ -740,12 +709,6 @@ fn merge_chains(
    let mut prev_orig_was_invalidated = false;
    let mut potentially_invalidated_heights = vec![];

-    // If we can, we want to return the update tip as the new tip because this allows checkpoints
-    // in multiple locations to keep the same `Arc` pointers when they are being updated from each
-    // other using this function. We can do this as long as long as the update contains every
-    // block's height of the original chain.
-    let mut is_update_height_superset_of_original = true;
-
    // To find the difference between the new chain and the original we iterate over both of them
    // from the tip backwards in tandem. We always dealing with the highest one from either chain
    // first and move to the next highest. The crucial logic is applied when they have blocks at the
@@ -771,8 +734,6 @@ fn merge_chains(
                prev_orig_was_invalidated = false;
                prev_orig = curr_orig.take();

-                is_update_height_superset_of_original = false;
-
                // OPTIMIZATION: we have run out of update blocks so we don't need to continue
                // iterating because there's no possibility of adding anything to changeset.
                if u.is_none() {
@@ -795,20 +756,12 @@ fn merge_chains(
                    }
                    point_of_agreement_found = true;
                    prev_orig_was_invalidated = false;
+                    // OPTIMIZATION 1 -- If we know that older blocks cannot be introduced without
+                    // invalidation, we can break after finding the point of agreement.
                    // OPTIMIZATION 2 -- if we have the same underlying pointer at this point, we
                    // can guarantee that no older blocks are introduced.
-                    if Arc::as_ptr(&o.0) == Arc::as_ptr(&u.0) {
-                        if is_update_height_superset_of_original {
-                            return Ok((update_tip, changeset));
-                        } else {
-                            let new_tip =
-                                original_tip.apply_changeset(&changeset).map_err(|_| {
-                                    CannotConnectError {
-                                        try_include_height: 0,
-                                    }
-                                })?;
-                            return Ok((new_tip, changeset));
-                        }
+                    if !introduce_older_blocks || Arc::as_ptr(&o.0) == Arc::as_ptr(&u.0) {
+                        return Ok(changeset);
                    }
                } else {
                    // We have an invalidation height so we set the height to the updated hash and
@@ -842,10 +795,5 @@ fn merge_chains(
        }
    }

-    let new_tip = original_tip
-        .apply_changeset(&changeset)
-        .map_err(|_| CannotConnectError {
-            try_include_height: 0,
-        })?;
-    Ok((new_tip, changeset))
+    Ok(changeset)
 }
--- a/crates/persist/src/persist.rs
+++ b/crates/persist/src/persist.rs
@@ -1,33 +1,26 @@
-extern crate alloc;
-use alloc::boxed::Box;
-use bdk_chain::Append;
-use core::fmt;
+use core::convert::Infallible;

-/// `Persist` wraps a [`PersistBackend`] to create a convenient staging area for changes (`C`)
+use crate::Append;
+
+/// `Persist` wraps a [`PersistBackend`] (`B`) to create a convenient staging area for changes (`C`)
 /// before they are persisted.
 ///
 /// Not all changes to the in-memory representation needs to be written to disk right away, so
 /// [`Persist::stage`] can be used to *stage* changes first and then [`Persist::commit`] can be used
 /// to write changes to disk.
-pub struct Persist<C> {
-    backend: Box<dyn PersistBackend<C> + Send + Sync>,
+#[derive(Debug)]
+pub struct Persist<B, C> {
+    backend: B,
    stage: C,
 }

-impl<C: fmt::Debug> fmt::Debug for Persist<C> {
-    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(fmt, "{:?}", self.stage)?;
-        Ok(())
-    }
-}
-
-impl<C> Persist<C>
+impl<B, C> Persist<B, C>
 where
+    B: PersistBackend<C>,
    C: Default + Append,
 {
    /// Create a new [`Persist`] from [`PersistBackend`].
-    pub fn new(backend: impl PersistBackend<C> + Send + Sync + 'static) -> Self {
-        let backend = Box::new(backend);
+    pub fn new(backend: B) -> Self {
        Self {
            backend,
            stage: Default::default(),
@@ -53,7 +46,7 @@ where
    /// # Error
    ///
    /// Returns a backend-defined error if this fails.
-    pub fn commit(&mut self) -> anyhow::Result<Option<C>> {
+    pub fn commit(&mut self) -> Result<Option<C>, B::WriteError> {
        if self.stage.is_empty() {
            return Ok(None);
        }
@@ -70,7 +63,7 @@ where
    ///
    /// [`stage`]: Self::stage
    /// [`commit`]: Self::commit
-    pub fn stage_and_commit(&mut self, changeset: C) -> anyhow::Result<Option<C>> {
+    pub fn stage_and_commit(&mut self, changeset: C) -> Result<Option<C>, B::WriteError> {
        self.stage(changeset);
        self.commit()
    }
@@ -81,6 +74,12 @@ where
 /// `C` represents the changeset; a datatype that records changes made to in-memory data structures
 /// that are to be persisted, or retrieved from persistence.
 pub trait PersistBackend<C> {
+    /// The error the backend returns when it fails to write.
+    type WriteError: core::fmt::Debug;
+
+    /// The error the backend returns when it fails to load changesets `C`.
+    type LoadError: core::fmt::Debug;
+
    /// Writes a changeset to the persistence backend.
    ///
    /// It is up to the backend what it does with this. It could store every changeset in a list or
@@ -89,18 +88,22 @@ pub trait PersistBackend<C> {
    /// changesets had been applied sequentially.
    ///
    /// [`load_from_persistence`]: Self::load_from_persistence
-    fn write_changes(&mut self, changeset: &C) -> anyhow::Result<()>;
+    fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError>;

    /// Return the aggregate changeset `C` from persistence.
-    fn load_from_persistence(&mut self) -> anyhow::Result<Option<C>>;
+    fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError>;
 }

 impl<C> PersistBackend<C> for () {
-    fn write_changes(&mut self, _changeset: &C) -> anyhow::Result<()> {
+    type WriteError = Infallible;
+
+    type LoadError = Infallible;
+
+    fn write_changes(&mut self, _changeset: &C) -> Result<(), Self::WriteError> {
        Ok(())
    }

-    fn load_from_persistence(&mut self) -> anyhow::Result<Option<C>> {
+    fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError> {
        Ok(None)
    }
 }
--- a/crates/chain/src/spk_client.rs
+++ b/crates/chain/src/spk_client.rs
@@ -1,387 +0,0 @@
-//! Helper types for spk-based blockchain clients.
-
-use core::{fmt::Debug, marker::PhantomData, ops::RangeBounds};
-
-use alloc::{boxed::Box, collections::BTreeMap, vec::Vec};
-use bitcoin::{OutPoint, Script, ScriptBuf, Txid};
-
-use crate::{local_chain::CheckPoint, ConfirmationTimeHeightAnchor, TxGraph};
-
-/// Data required to perform a spk-based blockchain client sync.
-///
-/// A client sync fetches relevant chain data for a known list of scripts, transaction ids and
-/// outpoints. The sync process also updates the chain from the given [`CheckPoint`].
-pub struct SyncRequest {
-    /// A checkpoint for the current chain [`LocalChain::tip`].
-    /// The sync process will return a new chain update that extends this tip.
-    ///
-    /// [`LocalChain::tip`]: crate::local_chain::LocalChain::tip
-    pub chain_tip: CheckPoint,
-    /// Transactions that spend from or to these indexed script pubkeys.
-    pub spks: Box<dyn ExactSizeIterator<Item = ScriptBuf> + Send>,
-    /// Transactions with these txids.
-    pub txids: Box<dyn ExactSizeIterator<Item = Txid> + Send>,
-    /// Transactions with these outpoints or spent from these outpoints.
-    pub outpoints: Box<dyn ExactSizeIterator<Item = OutPoint> + Send>,
-}
-
-impl SyncRequest {
-    /// Construct a new [`SyncRequest`] from a given `cp` tip.
-    pub fn from_chain_tip(cp: CheckPoint) -> Self {
-        Self {
-            chain_tip: cp,
-            spks: Box::new(core::iter::empty()),
-            txids: Box::new(core::iter::empty()),
-            outpoints: Box::new(core::iter::empty()),
-        }
-    }
-
-    /// Set the [`Script`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn set_spks(
-        mut self,
-        spks: impl IntoIterator<IntoIter = impl ExactSizeIterator<Item = ScriptBuf> + Send + 'static>,
-    ) -> Self {
-        self.spks = Box::new(spks.into_iter());
-        self
-    }
-
-    /// Set the [`Txid`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn set_txids(
-        mut self,
-        txids: impl IntoIterator<IntoIter = impl ExactSizeIterator<Item = Txid> + Send + 'static>,
-    ) -> Self {
-        self.txids = Box::new(txids.into_iter());
-        self
-    }
-
-    /// Set the [`OutPoint`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn set_outpoints(
-        mut self,
-        outpoints: impl IntoIterator<
-            IntoIter = impl ExactSizeIterator<Item = OutPoint> + Send + 'static,
-        >,
-    ) -> Self {
-        self.outpoints = Box::new(outpoints.into_iter());
-        self
-    }
-
-    /// Chain on additional [`Script`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn chain_spks(
-        mut self,
-        spks: impl IntoIterator<
-            IntoIter = impl ExactSizeIterator<Item = ScriptBuf> + Send + 'static,
-            Item = ScriptBuf,
-        >,
-    ) -> Self {
-        self.spks = Box::new(ExactSizeChain::new(self.spks, spks.into_iter()));
-        self
-    }
-
-    /// Chain on additional [`Txid`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn chain_txids(
-        mut self,
-        txids: impl IntoIterator<
-            IntoIter = impl ExactSizeIterator<Item = Txid> + Send + 'static,
-            Item = Txid,
-        >,
-    ) -> Self {
-        self.txids = Box::new(ExactSizeChain::new(self.txids, txids.into_iter()));
-        self
-    }
-
-    /// Chain on additional [`OutPoint`]s that will be synced against.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn chain_outpoints(
-        mut self,
-        outpoints: impl IntoIterator<
-            IntoIter = impl ExactSizeIterator<Item = OutPoint> + Send + 'static,
-            Item = OutPoint,
-        >,
-    ) -> Self {
-        self.outpoints = Box::new(ExactSizeChain::new(self.outpoints, outpoints.into_iter()));
-        self
-    }
-
-    /// Add a closure that will be called for [`Script`]s previously added to this request.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn inspect_spks(
-        mut self,
-        mut inspect: impl FnMut(&Script) + Send + Sync + 'static,
-    ) -> Self {
-        self.spks = Box::new(self.spks.inspect(move |spk| inspect(spk)));
-        self
-    }
-
-    /// Add a closure that will be called for [`Txid`]s previously added to this request.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn inspect_txids(mut self, mut inspect: impl FnMut(&Txid) + Send + Sync + 'static) -> Self {
-        self.txids = Box::new(self.txids.inspect(move |txid| inspect(txid)));
-        self
-    }
-
-    /// Add a closure that will be called for [`OutPoint`]s previously added to this request.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn inspect_outpoints(
-        mut self,
-        mut inspect: impl FnMut(&OutPoint) + Send + Sync + 'static,
-    ) -> Self {
-        self.outpoints = Box::new(self.outpoints.inspect(move |op| inspect(op)));
-        self
-    }
-
-    /// Populate the request with revealed script pubkeys from `index` with the given `spk_range`.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[cfg(feature = "miniscript")]
-    #[must_use]
-    pub fn populate_with_revealed_spks<K: Clone + Ord + Debug + Send + Sync>(
-        self,
-        index: &crate::keychain::KeychainTxOutIndex<K>,
-        spk_range: impl RangeBounds<K>,
-    ) -> Self {
-        use alloc::borrow::ToOwned;
-        self.chain_spks(
-            index
-                .revealed_spks(spk_range)
-                .map(|(_, _, spk)| spk.to_owned())
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-/// Data returned from a spk-based blockchain client sync.
-///
-/// See also [`SyncRequest`].
-pub struct SyncResult<A = ConfirmationTimeHeightAnchor> {
-    /// The update to apply to the receiving [`TxGraph`].
-    pub graph_update: TxGraph<A>,
-    /// The update to apply to the receiving [`LocalChain`](crate::local_chain::LocalChain).
-    pub chain_update: CheckPoint,
-}
-
-/// Data required to perform a spk-based blockchain client full scan.
-///
-/// A client full scan iterates through all the scripts for the given keychains, fetching relevant
-/// data until some stop gap number of scripts is found that have no data. This operation is
-/// generally only used when importing or restoring previously used keychains in which the list of
-/// used scripts is not known. The full scan process also updates the chain from the given [`CheckPoint`].
-pub struct FullScanRequest<K> {
-    /// A checkpoint for the current [`LocalChain::tip`].
-    /// The full scan process will return a new chain update that extends this tip.
-    ///
-    /// [`LocalChain::tip`]: crate::local_chain::LocalChain::tip
-    pub chain_tip: CheckPoint,
-    /// Iterators of script pubkeys indexed by the keychain index.
-    pub spks_by_keychain: BTreeMap<K, Box<dyn Iterator<Item = (u32, ScriptBuf)> + Send>>,
-}
-
-impl<K: Ord + Clone> FullScanRequest<K> {
-    /// Construct a new [`FullScanRequest`] from a given `chain_tip`.
-    #[must_use]
-    pub fn from_chain_tip(chain_tip: CheckPoint) -> Self {
-        Self {
-            chain_tip,
-            spks_by_keychain: BTreeMap::new(),
-        }
-    }
-
-    /// Construct a new [`FullScanRequest`] from a given `chain_tip` and `index`.
-    ///
-    /// Unbounded script pubkey iterators for each keychain (`K`) are extracted using
-    /// [`KeychainTxOutIndex::all_unbounded_spk_iters`] and is used to populate the
-    /// [`FullScanRequest`].
-    ///
-    /// [`KeychainTxOutIndex::all_unbounded_spk_iters`]: crate::keychain::KeychainTxOutIndex::all_unbounded_spk_iters
-    #[cfg(feature = "miniscript")]
-    #[must_use]
-    pub fn from_keychain_txout_index(
-        chain_tip: CheckPoint,
-        index: &crate::keychain::KeychainTxOutIndex<K>,
-    ) -> Self
-    where
-        K: Debug,
-    {
-        let mut req = Self::from_chain_tip(chain_tip);
-        for (keychain, spks) in index.all_unbounded_spk_iters() {
-            req = req.set_spks_for_keychain(keychain, spks);
-        }
-        req
-    }
-
-    /// Set the [`Script`]s for a given `keychain`.
-    ///
-    /// This consumes the [`FullScanRequest`] and returns the updated one.
-    #[must_use]
-    pub fn set_spks_for_keychain(
-        mut self,
-        keychain: K,
-        spks: impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send + 'static>,
-    ) -> Self {
-        self.spks_by_keychain
-            .insert(keychain, Box::new(spks.into_iter()));
-        self
-    }
-
-    /// Chain on additional [`Script`]s that will be synced against.
-    ///
-    /// This consumes the [`FullScanRequest`] and returns the updated one.
-    #[must_use]
-    pub fn chain_spks_for_keychain(
-        mut self,
-        keychain: K,
-        spks: impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send + 'static>,
-    ) -> Self {
-        match self.spks_by_keychain.remove(&keychain) {
-            // clippy here suggests to remove `into_iter` from `spks.into_iter()`, but doing so
-            // results in a compilation error
-            #[allow(clippy::useless_conversion)]
-            Some(keychain_spks) => self
-                .spks_by_keychain
-                .insert(keychain, Box::new(keychain_spks.chain(spks.into_iter()))),
-            None => self
-                .spks_by_keychain
-                .insert(keychain, Box::new(spks.into_iter())),
-        };
-        self
-    }
-
-    /// Add a closure that will be called for every [`Script`] previously added to any keychain in
-    /// this request.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn inspect_spks_for_all_keychains(
-        mut self,
-        inspect: impl FnMut(K, u32, &Script) + Send + Sync + Clone + 'static,
-    ) -> Self
-    where
-        K: Send + 'static,
-    {
-        for (keychain, spks) in core::mem::take(&mut self.spks_by_keychain) {
-            let mut inspect = inspect.clone();
-            self.spks_by_keychain.insert(
-                keychain.clone(),
-                Box::new(spks.inspect(move |(i, spk)| inspect(keychain.clone(), *i, spk))),
-            );
-        }
-        self
-    }
-
-    /// Add a closure that will be called for every [`Script`] previously added to a given
-    /// `keychain` in this request.
-    ///
-    /// This consumes the [`SyncRequest`] and returns the updated one.
-    #[must_use]
-    pub fn inspect_spks_for_keychain(
-        mut self,
-        keychain: K,
-        mut inspect: impl FnMut(u32, &Script) + Send + Sync + 'static,
-    ) -> Self
-    where
-        K: Send + 'static,
-    {
-        if let Some(spks) = self.spks_by_keychain.remove(&keychain) {
-            self.spks_by_keychain.insert(
-                keychain,
-                Box::new(spks.inspect(move |(i, spk)| inspect(*i, spk))),
-            );
-        }
-        self
-    }
-}
-
-/// Data returned from a spk-based blockchain client full scan.
-///
-/// See also [`FullScanRequest`].
-pub struct FullScanResult<K> {
-    /// The update to apply to the receiving [`LocalChain`](crate::local_chain::LocalChain).
-    pub graph_update: TxGraph<ConfirmationTimeHeightAnchor>,
-    /// The update to apply to the receiving [`TxGraph`].
-    pub chain_update: CheckPoint,
-    /// Last active indices for the corresponding keychains (`K`).
-    pub last_active_indices: BTreeMap<K, u32>,
-}
-
-/// A version of [`core::iter::Chain`] which can combine two [`ExactSizeIterator`]s to form a new
-/// [`ExactSizeIterator`].
-///
-/// The danger of this is explained in [the `ExactSizeIterator` docs]
-/// (https://doc.rust-lang.org/core/iter/trait.ExactSizeIterator.html#when-shouldnt-an-adapter-be-exactsizeiterator).
-/// This does not apply here since it would be impossible to scan an item count that overflows
-/// `usize` anyway.
-struct ExactSizeChain<A, B, I> {
-    a: Option<A>,
-    b: Option<B>,
-    i: PhantomData<I>,
-}
-
-impl<A, B, I> ExactSizeChain<A, B, I> {
-    fn new(a: A, b: B) -> Self {
-        ExactSizeChain {
-            a: Some(a),
-            b: Some(b),
-            i: PhantomData,
-        }
-    }
-}
-
-impl<A, B, I> Iterator for ExactSizeChain<A, B, I>
-where
-    A: Iterator<Item = I>,
-    B: Iterator<Item = I>,
-{
-    type Item = I;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(a) = &mut self.a {
-            let item = a.next();
-            if item.is_some() {
-                return item;
-            }
-            self.a = None;
-        }
-        if let Some(b) = &mut self.b {
-            let item = b.next();
-            if item.is_some() {
-                return item;
-            }
-            self.b = None;
-        }
-        None
-    }
-}
-
-impl<A, B, I> ExactSizeIterator for ExactSizeChain<A, B, I>
-where
-    A: ExactSizeIterator<Item = I>,
-    B: ExactSizeIterator<Item = I>,
-{
-    fn len(&self) -> usize {
-        let a_len = self.a.as_ref().map(|a| a.len()).unwrap_or(0);
-        let b_len = self.b.as_ref().map(|a| a.len()).unwrap_or(0);
-        a_len + b_len
-    }
-}
--- a/crates/chain/src/spk_iter.rs
+++ b/crates/chain/src/spk_iter.rs
@@ -260,7 +260,6 @@ mod test {
    }

    // The following dummy traits were created to test if SpkIterator is working properly.
-    #[allow(unused)]
    trait TestSendStatic: Send + 'static {
        fn test(&self) -> u32 {
            20
--- a/crates/chain/src/spk_txout_index.rs
+++ b/crates/chain/src/spk_txout_index.rs
@@ -4,7 +4,7 @@ use crate::{
    collections::{hash_map::Entry, BTreeMap, BTreeSet, HashMap},
    indexed_tx_graph::Indexer,
 };
-use bitcoin::{OutPoint, Script, ScriptBuf, Transaction, TxOut, Txid};
+use bitcoin::{self, OutPoint, Script, ScriptBuf, Transaction, TxOut, Txid};

 /// An index storing [`TxOut`]s that have a script pubkey that matches those in a list.
 ///
@@ -229,7 +229,7 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
    /// Here, "unused" means that after the script pubkey was stored in the index, the index has
    /// never scanned a transaction output with it.
    pub fn is_used(&self, index: &I) -> bool {
-        !self.unused.contains(index)
+        self.unused.get(index).is_none()
    }

    /// Marks the script pubkey at `index` as used even though it hasn't seen an output spending to it.
@@ -270,39 +270,36 @@ impl<I: Clone + Ord> SpkTxOutIndex<I> {
        self.spk_indices.get(script)
    }

-    /// Computes the total value transfer effect `tx` has on the script pubkeys in `range`. Value is
-    /// *sent* when a script pubkey in the `range` is on an input and *received* when it is on an
-    /// output. For `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.
-    pub fn sent_and_received(&self, tx: &Transaction, range: impl RangeBounds<I>) -> (u64, u64) {
+    /// 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.
+    pub fn sent_and_received(&self, tx: &Transaction) -> (u64, u64) {
        let mut sent = 0;
        let mut received = 0;

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

        (sent, received)
    }

-    /// Computes the net value transfer effect of `tx` on the script pubkeys in `range`. Shorthand
-    /// for calling [`sent_and_received`] and subtracting sent from received.
+    /// 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.
    ///
    /// [`sent_and_received`]: Self::sent_and_received
-    pub fn net_value(&self, tx: &Transaction, range: impl RangeBounds<I>) -> i64 {
-        let (sent, received) = self.sent_and_received(tx, range);
+    pub fn net_value(&self, tx: &Transaction) -> i64 {
+        let (sent, received) = self.sent_and_received(tx);
        received as i64 - sent as i64
    }

--- a/crates/chain/src/tx_graph.rs
+++ b/crates/chain/src/tx_graph.rs
@@ -1,27 +1,26 @@
 //! Module for structures that store and traverse transactions.
 //!
-//! [`TxGraph`] contains transactions and indexes them so you can easily traverse the graph of
-//! those transactions. `TxGraph` is *monotone* in that you can always insert a transaction -- it
-//! does not care whether that transaction is in the current best chain or whether it conflicts with
-//! any of the existing transactions or what order you insert the transactions. This means that you
-//! can always combine two [`TxGraph`]s together, without resulting in inconsistencies. Furthermore,
-//! there is currently no way to delete a transaction.
+//! [`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.).
+//! Transactions can be either whole or partial (i.e., transactions for which we only
+//! know some outputs, which we usually call "floating outputs"; these are usually inserted
+//! using the [`insert_txout`] method.).
 //!
-//! The graph contains transactions in the form of [`TxNode`]s. Each node contains the txid, the
-//! transaction (whole or partial), the blocks that it is anchored to (see the [`Anchor`]
-//! documentation for more details), and the timestamp of the last time we saw the transaction as
-//! unconfirmed.
+//! 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.
 //!
 //! Conflicting transactions are allowed to coexist within a [`TxGraph`]. This is useful for
 //! identifying and traversing conflicts and descendants of a given transaction. Some [`TxGraph`]
-//! methods only consider transactions that are "canonical" (i.e., in the best chain or in mempool).
-//! We decide which transactions are canonical based on the transaction's anchors and the
-//! `last_seen` (as unconfirmed) timestamp; see the [`try_get_chain_position`] documentation for
-//! more details.
+//! 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`].
@@ -31,22 +30,10 @@
 //!
 //! # Applying changes
 //!
-//! Methods that change the state of [`TxGraph`] will return [`ChangeSet`]s.
-//! [`ChangeSet`]s can be applied back to a [`TxGraph`] or be used to inform persistent storage
+//! Methods that apply changes to [`TxGraph`] will return [`ChangeSet`].
+//! [`ChangeSet`] can be applied back to a [`TxGraph`] or be used to inform persistent storage
 //! of the changes to [`TxGraph`].
 //!
-//! # Generics
-//!
-//! Anchors are represented as generics within `TxGraph<A>`. To make use of all functionality of the
-//! `TxGraph`, anchors (`A`) should implement [`Anchor`].
-//!
-//! Anchors are made generic so that different types of data can be stored with how a transaction is
-//! *anchored* to a given block. An example of this is storing a merkle proof of the transaction to
-//! the confirmation block - this can be done with a custom [`Anchor`] type. The minimal [`Anchor`]
-//! type would just be a [`BlockId`] which just represents the height and hash of the block which
-//! the transaction is contained in. Note that a transaction can be contained in multiple
-//! conflicting blocks (by nature of the Bitcoin network).
-//!
 //! ```
 //! # use bdk_chain::BlockId;
 //! # use bdk_chain::tx_graph::TxGraph;
@@ -89,11 +76,10 @@
 //! [`insert_txout`]: TxGraph::insert_txout

 use crate::{
-    collections::*, keychain::Balance, Anchor, Append, BlockId, ChainOracle, ChainPosition,
-    FullTxOut,
+    collections::*, keychain::Balance, local_chain::LocalChain, Anchor, Append, BlockId,
+    ChainOracle, ChainPosition, FullTxOut,
 };
 use alloc::collections::vec_deque::VecDeque;
-use alloc::sync::Arc;
 use alloc::vec::Vec;
 use bitcoin::{OutPoint, Script, Transaction, TxOut, Txid};
 use core::fmt::{self, Formatter};
@@ -136,7 +122,7 @@ pub struct TxNode<'a, T, A> {
    /// Txid of the transaction.
    pub txid: Txid,
    /// A partial or full representation of the transaction.
-    pub tx: T,
+    pub tx: &'a T,
    /// The blocks that the transaction is "anchored" in.
    pub anchors: &'a BTreeSet<A>,
    /// The last-seen unix timestamp of the transaction as unconfirmed.
@@ -147,7 +133,7 @@ impl<'a, T, A> Deref for TxNode<'a, T, A> {
    type Target = T;

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

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

@@ -212,7 +198,6 @@ impl<A> TxGraph<A> {
    pub fn all_txouts(&self) -> impl Iterator<Item = (OutPoint, &TxOut)> {
        self.txs.iter().flat_map(|(txid, (tx, _, _))| match tx {
            TxNodeInternal::Whole(tx) => tx
-                .as_ref()
                .output
                .iter()
                .enumerate()
@@ -244,13 +229,13 @@ impl<A> TxGraph<A> {
    }

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

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

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

        let fee = inputs_sum - outputs_sum;
@@ -372,15 +356,16 @@ impl<A> TxGraph<A> {
        &self,
        txid: Txid,
    ) -> impl DoubleEndedIterator<Item = (u32, &HashSet<Txid>)> + '_ {
-        let start = OutPoint::new(txid, 0);
-        let end = OutPoint::new(txid, u32::MAX);
+        let start = OutPoint { txid, vout: 0 };
+        let end = OutPoint {
+            txid,
+            vout: u32::MAX,
+        };
        self.spends
            .range(start..=end)
            .map(|(outpoint, spends)| (outpoint.vout, spends))
    }
-}

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

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

@@ -444,7 +430,7 @@ impl<A> TxGraph<A> {
    /// Note that this only returns directly conflicting txids and won't include:
    /// - descendants of conflicting transactions (which are technically also conflicting)
    /// - transactions conflicting with the given transaction's ancestors
-    pub fn direct_conflicts<'g>(
+    pub fn direct_conflitcs<'g>(
        &'g self,
        tx: &'g Transaction,
    ) -> impl Iterator<Item = (usize, Txid)> + '_ {
@@ -481,7 +467,9 @@ impl<A: Clone + Ord> TxGraph<A> {
        new_graph.apply_changeset(self.initial_changeset().map_anchors(f));
        new_graph
    }
+}

+impl<A: Clone + Ord> TxGraph<A> {
    /// Construct a new [`TxGraph`] from a list of transactions.
    pub fn new(txs: impl IntoIterator<Item = Transaction>) -> Self {
        let mut new = Self::default();
@@ -518,10 +506,9 @@ impl<A: Clone + Ord> TxGraph<A> {
    /// The [`ChangeSet`] returned will be empty if `tx` already exists.
    pub fn insert_tx(&mut self, tx: Transaction) -> ChangeSet<A> {
        let mut update = Self::default();
-        update.txs.insert(
-            tx.txid(),
-            (TxNodeInternal::Whole(tx.into()), BTreeSet::new(), 0),
-        );
+        update
+            .txs
+            .insert(tx.txid(), (TxNodeInternal::Whole(tx), BTreeSet::new(), 0));
        self.apply_update(update)
    }

@@ -554,11 +541,7 @@ impl<A: Clone + Ord> TxGraph<A> {

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

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

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

            tx.input
@@ -659,20 +582,18 @@ impl<A: Clone + Ord> TxGraph<A> {

            match self.txs.get_mut(&txid) {
                Some((tx_node @ TxNodeInternal::Partial(_), _, _)) => {
-                    *tx_node = TxNodeInternal::Whole(wrapped_tx.clone());
+                    *tx_node = TxNodeInternal::Whole(tx);
                }
                Some((TxNodeInternal::Whole(tx), _, _)) => {
                    debug_assert_eq!(
-                        tx.as_ref().txid(),
+                        tx.txid(),
                        txid,
                        "tx should produce txid that is same as key"
                    );
                }
                None => {
-                    self.txs.insert(
-                        txid,
-                        (TxNodeInternal::Whole(wrapped_tx), BTreeSet::new(), 0),
-                    );
+                    self.txs
+                        .insert(txid, (TxNodeInternal::Whole(tx), BTreeSet::new(), 0));
                }
            }
        }
@@ -709,7 +630,7 @@ impl<A: Clone + Ord> TxGraph<A> {
    /// The [`ChangeSet`] would be the set difference between `update` and `self` (transactions that
    /// exist in `update` but not in `self`).
    pub(crate) fn determine_changeset(&self, update: TxGraph<A>) -> ChangeSet<A> {
-        let mut changeset = ChangeSet::<A>::default();
+        let mut changeset = ChangeSet::default();

        for (&txid, (update_tx_node, _, update_last_seen)) in &update.txs {
            let prev_last_seen: u64 = match (self.txs.get(&txid), update_tx_node) {
@@ -759,6 +680,69 @@ impl<A: Clone + Ord> TxGraph<A> {
 }

 impl<A: Anchor> TxGraph<A> {
+    /// Find missing block heights of `chain`.
+    ///
+    /// This works by scanning through anchors, and seeing whether the anchor block of the anchor
+    /// exists in the [`LocalChain`]. The returned iterator does not output duplicate heights.
+    pub fn missing_heights<'a>(&'a self, chain: &'a LocalChain) -> impl Iterator<Item = u32> + 'a {
+        // Map of txids to skip.
+        //
+        // Usually, if a height of a tx anchor is missing from the chain, we would want to return
+        // this height in the iterator. The exception is when the tx is confirmed in chain. All the
+        // other missing-height anchors of this tx can be skipped.
+        //
+        // * Some(true)  => skip all anchors of this txid
+        // * Some(false) => do not skip anchors of this txid
+        // * None        => we do not know whether we can skip this txid
+        let mut txids_to_skip = HashMap::<Txid, bool>::new();
+
+        // Keeps track of the last height emitted so we don't double up.
+        let mut last_height_emitted = Option::<u32>::None;
+
+        self.anchors
+            .iter()
+            .filter(move |(_, txid)| {
+                let skip = *txids_to_skip.entry(*txid).or_insert_with(|| {
+                    let tx_anchors = match self.txs.get(txid) {
+                        Some((_, anchors, _)) => anchors,
+                        None => return true,
+                    };
+                    let mut has_missing_height = false;
+                    for anchor_block in tx_anchors.iter().map(Anchor::anchor_block) {
+                        match chain.blocks().get(&anchor_block.height) {
+                            None => {
+                                has_missing_height = true;
+                                continue;
+                            }
+                            Some(chain_hash) => {
+                                if chain_hash == &anchor_block.hash {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    !has_missing_height
+                });
+                #[cfg(feature = "std")]
+                debug_assert!({
+                    println!("txid={} skip={}", txid, skip);
+                    true
+                });
+                !skip
+            })
+            .filter_map(move |(a, _)| {
+                let anchor_block = a.anchor_block();
+                if Some(anchor_block.height) != last_height_emitted
+                    && !chain.blocks().contains_key(&anchor_block.height)
+                {
+                    last_height_emitted = Some(anchor_block.height);
+                    Some(anchor_block.height)
+                } else {
+                    None
+                }
+            })
+    }
+
    /// Get the position of the transaction in `chain` with tip `chain_tip`.
    ///
    /// Chain data is fetched from `chain`, a [`ChainOracle`] implementation.
@@ -807,10 +791,10 @@ impl<A: Anchor> TxGraph<A> {
            TxNodeInternal::Whole(tx) => {
                // A coinbase tx that is not anchored in the best chain cannot be unconfirmed and
                // should always be filtered out.
-                if tx.is_coinbase() {
+                if tx.is_coin_base() {
                    return Ok(None);
                }
-                tx.clone()
+                tx
            }
            TxNodeInternal::Partial(_) => {
                // Partial transactions (outputs only) cannot have conflicts.
@@ -827,8 +811,8 @@ impl<A: Anchor> TxGraph<A> {
        // First of all, we retrieve all our ancestors. Since we're using `new_include_root`, the
        // resulting array will also include `tx`
        let unconfirmed_ancestor_txs =
-            TxAncestors::new_include_root(self, tx.clone(), |_, ancestor_tx: Arc<Transaction>| {
-                let tx_node = self.get_tx_node(ancestor_tx.as_ref().txid())?;
+            TxAncestors::new_include_root(self, tx, |_, ancestor_tx: &Transaction| {
+                let tx_node = self.get_tx_node(ancestor_tx.txid())?;
                // We're filtering the ancestors to keep only the unconfirmed ones (= no anchors in
                // the best chain)
                for block in tx_node.anchors {
@@ -844,10 +828,8 @@ impl<A: Anchor> TxGraph<A> {

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

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

            // If a conflicting tx is in the best chain, or has `last_seen` higher than this ancestor, then
            // this tx cannot exist in the best chain
@@ -887,7 +867,7 @@ impl<A: Anchor> TxGraph<A> {
                    return Ok(None);
                }
                if conflicting_tx.last_seen_unconfirmed == *last_seen
-                    && conflicting_tx.as_ref().txid() > tx.as_ref().txid()
+                    && conflicting_tx.txid() > tx.txid()
                {
                    // Conflicting tx has priority if txid of conflicting tx > txid of original tx
                    return Ok(None);
@@ -980,7 +960,7 @@ impl<A: Anchor> TxGraph<A> {
        &'a self,
        chain: &'a C,
        chain_tip: BlockId,
-    ) -> impl Iterator<Item = Result<CanonicalTx<'a, Arc<Transaction>, A>, C::Error>> {
+    ) -> impl Iterator<Item = Result<CanonicalTx<'a, Transaction, A>, C::Error>> {
        self.full_txs().filter_map(move |tx| {
            self.try_get_chain_position(chain, chain_tip, tx.txid)
                .map(|v| {
@@ -1002,7 +982,7 @@ impl<A: Anchor> TxGraph<A> {
        &'a self,
        chain: &'a C,
        chain_tip: BlockId,
-    ) -> impl Iterator<Item = CanonicalTx<'a, Arc<Transaction>, A>> {
+    ) -> impl Iterator<Item = CanonicalTx<'a, Transaction, A>> {
        self.try_list_chain_txs(chain, chain_tip)
            .map(|r| r.expect("oracle is infallible"))
    }
@@ -1041,7 +1021,7 @@ impl<A: Anchor> TxGraph<A> {
                        None => return Ok(None),
                    };

-                    let txout = match tx_node.tx.as_ref().output.get(op.vout as usize) {
+                    let txout = match tx_node.tx.output.get(op.vout as usize) {
                        Some(txout) => txout.clone(),
                        None => return Ok(None),
                    };
@@ -1063,7 +1043,7 @@ impl<A: Anchor> TxGraph<A> {
                            txout,
                            chain_position,
                            spent_by,
-                            is_on_coinbase: tx_node.tx.is_coinbase(),
+                            is_on_coinbase: tx_node.tx.is_coin_base(),
                        },
                    )))
                },
@@ -1166,16 +1146,16 @@ impl<A: Anchor> TxGraph<A> {
            match &txout.chain_position {
                ChainPosition::Confirmed(_) => {
                    if txout.is_confirmed_and_spendable(chain_tip.height) {
-                        confirmed += txout.txout.value.to_sat();
+                        confirmed += txout.txout.value;
                    } else if !txout.is_mature(chain_tip.height) {
-                        immature += txout.txout.value.to_sat();
+                        immature += txout.txout.value;
                    }
                }
                ChainPosition::Unconfirmed(_) => {
                    if trust_predicate(&spk_i, &txout.txout.script_pubkey) {
-                        trusted_pending += txout.txout.value.to_sat();
+                        trusted_pending += txout.txout.value;
                    } else {
-                        untrusted_pending += txout.txout.value.to_sat();
+                        untrusted_pending += txout.txout.value;
                    }
                }
            }
@@ -1229,7 +1209,7 @@ impl<A: Anchor> TxGraph<A> {
 #[must_use]
 pub struct ChangeSet<A = ()> {
    /// Added transactions.
-    pub txs: BTreeSet<Arc<Transaction>>,
+    pub txs: BTreeSet<Transaction>,
    /// Added txouts.
    pub txouts: BTreeMap<OutPoint, TxOut>,
    /// Added anchors.
@@ -1267,6 +1247,8 @@ impl<A> ChangeSet<A> {
    ///
    /// This is useful if you want to find which heights you need to fetch data about in order to
    /// confirm or exclude these anchors.
+    ///
+    /// See also: [`TxGraph::missing_heights`]
    pub fn anchor_heights(&self) -> impl Iterator<Item = u32> + '_
    where
        A: Anchor,
@@ -1281,6 +1263,24 @@ impl<A> ChangeSet<A> {
                !duplicate
            })
    }
+
+    /// Returns an iterator for the [`anchor_heights`] in this changeset that are not included in
+    /// `local_chain`. This tells you which heights you need to include in `local_chain` in order
+    /// for it to conclusively act as a [`ChainOracle`] for the transaction anchors this changeset
+    /// will add.
+    ///
+    /// [`ChainOracle`]: crate::ChainOracle
+    /// [`anchor_heights`]: Self::anchor_heights
+    pub fn missing_heights_from<'a>(
+        &'a self,
+        local_chain: &'a LocalChain,
+    ) -> impl Iterator<Item = u32> + 'a
+    where
+        A: Anchor,
+    {
+        self.anchor_heights()
+            .filter(move |height| !local_chain.blocks().contains_key(height))
+    }
 }

 impl<A: Ord> Append for ChangeSet<A> {
@@ -1345,7 +1345,7 @@ impl<A> AsRef<TxGraph<A>> for TxGraph<A> {
 pub struct TxAncestors<'g, A, F> {
    graph: &'g TxGraph<A>,
    visited: HashSet<Txid>,
-    queue: VecDeque<(usize, Arc<Transaction>)>,
+    queue: VecDeque<(usize, &'g Transaction)>,
    filter_map: F,
 }

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

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

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

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

@@ -1447,7 +1445,7 @@ where
            // we have exhausted all paths when queue is empty
            let (ancestor_depth, tx) = self.queue.pop_front()?;
            // ignore paths when user filters them out
-            let item = match (self.filter_map)(ancestor_depth, tx.clone()) {
+            let item = match (self.filter_map)(ancestor_depth, tx) {
                Some(item) => item,
                None => continue,
            };
--- a/crates/chain/tests/common/mod.rs
+++ b/crates/chain/tests/common/mod.rs
@@ -32,9 +32,12 @@ macro_rules! local_chain {
 macro_rules! chain_update {
    [ $(($height:expr, $hash:expr)), * ] => {{
        #[allow(unused_mut)]
-        bdk_chain::local_chain::LocalChain::from_blocks([$(($height, $hash).into()),*].into_iter().collect())
-            .expect("chain must have genesis block")
-            .tip()
+        bdk_chain::local_chain::Update {
+            tip: bdk_chain::local_chain::LocalChain::from_blocks([$(($height, $hash).into()),*].into_iter().collect())
+                .expect("chain must have genesis block")
+                .tip(),
+            introduce_older_blocks: true,
+        }
    }};
 }

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

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

@@ -68,7 +68,7 @@ pub fn init_graph<'a, A: Anchor + Clone + 'a>(

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

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

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

 /// Ensure [`IndexedTxGraph::insert_relevant_txs`] can successfully index transactions NOT presented
@@ -37,11 +35,11 @@ fn insert_relevant_txs() {
    let tx_a = Transaction {
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: spk_0,
            },
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: spk_1,
            },
        ],
@@ -68,7 +66,7 @@ fn insert_relevant_txs() {

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

+#[test]
 /// Ensure consistency IndexedTxGraph list_* and balance methods. These methods lists
 /// relevant txouts and utxos from the information fetched from a ChainOracle (here a LocalChain).
 ///
@@ -109,7 +108,7 @@ fn insert_relevant_txs() {
 ///
 /// Finally Add more blocks to local chain until tx1 coinbase maturity hits.
 /// Assert maturity at coinbase maturity inflection height. Block height 98 and 99.
-#[test]
+
 fn test_list_owned_txouts() {
    // Create Local chains
    let local_chain = LocalChain::from_blocks((0..150).map(|i| (i as u32, h!("random"))).collect())
@@ -156,7 +155,7 @@ fn test_list_owned_txouts() {
            ..Default::default()
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(70000),
+            value: 70000,
            script_pubkey: trusted_spks[0].to_owned(),
        }],
        ..common::new_tx(0)
@@ -165,7 +164,7 @@ fn test_list_owned_txouts() {
    // tx2 is an incoming transaction received at untrusted keychain at block 1.
    let tx2 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(30000),
+            value: 30000,
            script_pubkey: untrusted_spks[0].to_owned(),
        }],
        ..common::new_tx(0)
@@ -178,7 +177,7 @@ fn test_list_owned_txouts() {
            ..Default::default()
        }],
        output: vec![TxOut {
-            value: Amount::from_sat(10000),
+            value: 10000,
            script_pubkey: trusted_spks[1].to_owned(),
        }],
        ..common::new_tx(0)
@@ -187,7 +186,7 @@ fn test_list_owned_txouts() {
    // tx4 is an external transaction receiving at untrusted keychain, unconfirmed.
    let tx4 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(20000),
+            value: 20000,
            script_pubkey: untrusted_spks[1].to_owned(),
        }],
        ..common::new_tx(0)
@@ -196,7 +195,7 @@ fn test_list_owned_txouts() {
    // tx5 is spending tx3 and receiving change at trusted keychain, unconfirmed.
    let tx5 = Transaction {
        output: vec![TxOut {
-            value: Amount::from_sat(15000),
+            value: 15000,
            script_pubkey: trusted_spks[2].to_owned(),
        }],
        ..common::new_tx(0)
@@ -214,8 +213,10 @@ fn test_list_owned_txouts() {
            (
                *tx,
                local_chain
-                    .get(height)
-                    .map(|cp| cp.block_id())
+                    .blocks()
+                    .get(&height)
+                    .cloned()
+                    .map(|hash| BlockId { height, hash })
                    .map(|anchor_block| ConfirmationHeightAnchor {
                        anchor_block,
                        confirmation_height: anchor_block.height,
@@ -230,8 +231,9 @@ fn test_list_owned_txouts() {
        |height: u32,
         graph: &IndexedTxGraph<ConfirmationHeightAnchor, KeychainTxOutIndex<String>>| {
            let chain_tip = local_chain
-                .get(height)
-                .map(|cp| cp.block_id())
+                .blocks()
+                .get(&height)
+                .map(|&hash| BlockId { height, hash })
                .unwrap_or_else(|| panic!("block must exist at {}", height));
            let txouts = graph
                .graph()
--- a/crates/chain/tests/test_keychain_txout_index.rs
+++ b/crates/chain/tests/test_keychain_txout_index.rs
@@ -9,7 +9,7 @@ use bdk_chain::{
    Append,
 };

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

 #[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]
@@ -176,14 +176,14 @@ fn test_lookahead() {
                        .at_derivation_index(external_index)
                        .unwrap()
                        .script_pubkey(),
-                    value: Amount::from_sat(10_000),
+                    value: 10_000,
                },
                TxOut {
                    script_pubkey: internal_desc
                        .at_derivation_index(internal_index)
                        .unwrap()
                        .script_pubkey(),
-                    value: Amount::from_sat(10_000),
+                    value: 10_000,
                },
            ],
            ..common::new_tx(external_index)
@@ -238,7 +238,7 @@ fn test_scan_with_lookahead() {
        let op = OutPoint::new(h!("fake tx"), spk_i);
        let txout = TxOut {
            script_pubkey: spk.clone(),
-            value: Amount::ZERO,
+            value: 0,
        };

        let changeset = txout_index.index_txout(op, &txout);
@@ -264,7 +264,7 @@ fn test_scan_with_lookahead() {
    let op = OutPoint::new(h!("fake tx"), 41);
    let txout = TxOut {
        script_pubkey: spk_41,
-        value: Amount::ZERO,
+        value: 0,
    };
    let changeset = txout_index.index_txout(op, &txout);
    assert!(changeset.is_empty());
--- a/crates/chain/tests/test_local_chain.rs
+++ b/crates/chain/tests/test_local_chain.rs
@@ -1,14 +1,11 @@
-use std::ops::{Bound, RangeBounds};
-
 use bdk_chain::{
    local_chain::{
        AlterCheckPointError, ApplyHeaderError, CannotConnectError, ChangeSet, CheckPoint,
-        LocalChain, MissingGenesisError,
+        LocalChain, MissingGenesisError, Update,
    },
    BlockId,
 };
 use bitcoin::{block::Header, hashes::Hash, BlockHash};
-use proptest::prelude::*;

 #[macro_use]
 mod common;
@@ -17,7 +14,7 @@ mod common;
 struct TestLocalChain<'a> {
    name: &'static str,
    chain: LocalChain,
-    update: CheckPoint,
+    update: Update,
    exp: ExpectedResult<'a>,
 }

@@ -531,123 +528,6 @@ fn checkpoint_from_block_ids() {
    }
 }

-#[test]
-fn checkpoint_query() {
-    struct TestCase {
-        chain: LocalChain,
-        /// The heights we want to call [`CheckPoint::query`] with, represented as an inclusive
-        /// range.
-        ///
-        /// If a [`CheckPoint`] exists at that height, we expect [`CheckPoint::query`] to return
-        /// it. If not, [`CheckPoint::query`] should return `None`.
-        query_range: (u32, u32),
-    }
-
-    let test_cases = [
-        TestCase {
-            chain: local_chain![(0, h!("_")), (1, h!("A"))],
-            query_range: (0, 2),
-        },
-        TestCase {
-            chain: local_chain![(0, h!("_")), (2, h!("B")), (3, h!("C"))],
-            query_range: (0, 3),
-        },
-    ];
-
-    for t in test_cases.into_iter() {
-        let tip = t.chain.tip();
-        for h in t.query_range.0..=t.query_range.1 {
-            let query_result = tip.get(h);
-
-            // perform an exhausitive search for the checkpoint at height `h`
-            let exp_hash = t
-                .chain
-                .iter_checkpoints()
-                .find(|cp| cp.height() == h)
-                .map(|cp| cp.hash());
-
-            match query_result {
-                Some(cp) => {
-                    assert_eq!(Some(cp.hash()), exp_hash);
-                    assert_eq!(cp.height(), h);
-                }
-                None => assert!(exp_hash.is_none()),
-            }
-        }
-    }
-}
-
-#[test]
-fn checkpoint_insert() {
-    struct TestCase<'a> {
-        /// The name of the test.
-        name: &'a str,
-        /// The original checkpoint chain to call [`CheckPoint::insert`] on.
-        chain: &'a [(u32, BlockHash)],
-        /// The `block_id` to insert.
-        to_insert: (u32, BlockHash),
-        /// The expected final checkpoint chain after calling [`CheckPoint::insert`].
-        exp_final_chain: &'a [(u32, BlockHash)],
-    }
-
-    let test_cases = [
-        TestCase {
-            name: "insert_above_tip",
-            chain: &[(1, h!("a")), (2, h!("b"))],
-            to_insert: (4, h!("d")),
-            exp_final_chain: &[(1, h!("a")), (2, h!("b")), (4, h!("d"))],
-        },
-        TestCase {
-            name: "insert_already_exists_expect_no_change",
-            chain: &[(1, h!("a")), (2, h!("b")), (3, h!("c"))],
-            to_insert: (2, h!("b")),
-            exp_final_chain: &[(1, h!("a")), (2, h!("b")), (3, h!("c"))],
-        },
-        TestCase {
-            name: "insert_in_middle",
-            chain: &[(2, h!("b")), (4, h!("d")), (5, h!("e"))],
-            to_insert: (3, h!("c")),
-            exp_final_chain: &[(2, h!("b")), (3, h!("c")), (4, h!("d")), (5, h!("e"))],
-        },
-        TestCase {
-            name: "replace_one",
-            chain: &[(3, h!("c")), (4, h!("d")), (5, h!("e"))],
-            to_insert: (5, h!("E")),
-            exp_final_chain: &[(3, h!("c")), (4, h!("d")), (5, h!("E"))],
-        },
-        TestCase {
-            name: "insert_conflict_should_evict",
-            chain: &[(3, h!("c")), (4, h!("d")), (5, h!("e")), (6, h!("f"))],
-            to_insert: (4, h!("D")),
-            exp_final_chain: &[(3, h!("c")), (4, h!("D"))],
-        },
-    ];
-
-    fn genesis_block() -> impl Iterator<Item = BlockId> {
-        core::iter::once((0, h!("_"))).map(BlockId::from)
-    }
-
-    for (i, t) in test_cases.into_iter().enumerate() {
-        println!("Running [{}] '{}'", i, t.name);
-
-        let chain = CheckPoint::from_block_ids(
-            genesis_block().chain(t.chain.iter().copied().map(BlockId::from)),
-        )
-        .expect("test formed incorrectly, must construct checkpoint chain");
-
-        let exp_final_chain = CheckPoint::from_block_ids(
-            genesis_block().chain(t.exp_final_chain.iter().copied().map(BlockId::from)),
-        )
-        .expect("test formed incorrectly, must construct checkpoint chain");
-
-        assert_eq!(
-            chain.insert(t.to_insert.into()),
-            exp_final_chain,
-            "unexpected final chain"
-        );
-    }
-}
-
 #[test]
 fn local_chain_apply_header_connected_to() {
    fn header_from_prev_blockhash(prev_blockhash: BlockHash) -> Header {
@@ -672,9 +552,9 @@ fn local_chain_apply_header_connected_to() {

    let test_cases = [
        {
-            let header = header_from_prev_blockhash(h!("_"));
+            let header = header_from_prev_blockhash(h!("A"));
            let hash = header.block_hash();
-            let height = 1;
+            let height = 2;
            let connected_to = BlockId { height, hash };
            TestCase {
                name: "connected_to_self_header_applied_to_self",
@@ -799,48 +679,3 @@ fn local_chain_apply_header_connected_to() {
        assert_eq!(result, exp_result, "[{}:{}] unexpected result", i, t.name);
    }
 }
-
-fn generate_height_range_bounds(
-    height_upper_bound: u32,
-) -> impl Strategy<Value = (Bound<u32>, Bound<u32>)> {
-    fn generate_height_bound(height_upper_bound: u32) -> impl Strategy<Value = Bound<u32>> {
-        prop_oneof![
-            (0..height_upper_bound).prop_map(Bound::Included),
-            (0..height_upper_bound).prop_map(Bound::Excluded),
-            Just(Bound::Unbounded),
-        ]
-    }
-    (
-        generate_height_bound(height_upper_bound),
-        generate_height_bound(height_upper_bound),
-    )
-}
-
-fn generate_checkpoints(max_height: u32, max_count: usize) -> impl Strategy<Value = CheckPoint> {
-    proptest::collection::btree_set(1..max_height, 0..max_count).prop_map(|mut heights| {
-        heights.insert(0); // must have genesis
-        CheckPoint::from_block_ids(heights.into_iter().map(|height| {
-            let hash = bitcoin::hashes::Hash::hash(height.to_le_bytes().as_slice());
-            BlockId { height, hash }
-        }))
-        .expect("blocks must be in order as it comes from btreeset")
-    })
-}
-
-proptest! {
-    #![proptest_config(ProptestConfig {
-        ..Default::default()
-    })]
-
-    /// Ensure that [`CheckPoint::range`] returns the expected checkpoint heights by comparing it
-    /// against a more primitive approach.
-    #[test]
-    fn checkpoint_range(
-        range in generate_height_range_bounds(21_000),
-        cp in generate_checkpoints(21_000, 2100)
-    ) {
-        let exp_heights = cp.iter().map(|cp| cp.height()).filter(|h| range.contains(h)).collect::<Vec<u32>>();
-        let heights = cp.range(range).map(|cp| cp.height()).collect::<Vec<u32>>();
-        prop_assert_eq!(heights, exp_heights);
-    }
-}
--- a/crates/chain/tests/test_spk_txout_index.rs
+++ b/crates/chain/tests/test_spk_txout_index.rs
@@ -1,5 +1,5 @@
 use bdk_chain::{indexed_tx_graph::Indexer, SpkTxOutIndex};
-use bitcoin::{absolute, transaction, Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut};
+use bitcoin::{absolute, OutPoint, ScriptBuf, Transaction, TxIn, TxOut};

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

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

-    assert_eq!(index.sent_and_received(&tx1, ..), (0, 42_000));
-    assert_eq!(index.sent_and_received(&tx1, ..1), (0, 42_000));
-    assert_eq!(index.sent_and_received(&tx1, 1..), (0, 0));
-    assert_eq!(index.net_value(&tx1, ..), 42_000);
+    assert_eq!(index.sent_and_received(&tx1), (0, 42_000));
+    assert_eq!(index.net_value(&tx1), 42_000);
    index.index_tx(&tx1);
    assert_eq!(
-        index.sent_and_received(&tx1, ..),
+        index.sent_and_received(&tx1),
        (0, 42_000),
        "shouldn't change after scanning"
    );

    let tx2 = Transaction {
-        version: transaction::Version::ONE,
+        version: 0x1,
        lock_time: absolute::LockTime::ZERO,
        input: vec![TxIn {
            previous_output: OutPoint {
@@ -43,20 +41,18 @@ fn spk_txout_sent_and_received() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: spk2,
            },
            TxOut {
                script_pubkey: spk1,
-                value: Amount::from_sat(30_000),
+                value: 30_000,
            },
        ],
    };

-    assert_eq!(index.sent_and_received(&tx2, ..), (42_000, 50_000));
-    assert_eq!(index.sent_and_received(&tx2, ..1), (42_000, 30_000));
-    assert_eq!(index.sent_and_received(&tx2, 1..), (0, 20_000));
-    assert_eq!(index.net_value(&tx2, ..), 8_000);
+    assert_eq!(index.sent_and_received(&tx2), (42_000, 50_000));
+    assert_eq!(index.net_value(&tx2), 8_000);
 }

 #[test]
@@ -77,11 +73,11 @@ fn mark_used() {
    assert!(spk_index.is_used(&1));

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

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

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

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

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

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

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

@@ -303,7 +298,7 @@ fn insert_tx_displaces_txouts() {
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(1_337_000),
+            value: 1_337_000,
            script_pubkey: ScriptBuf::default(),
        },
    );
@@ -316,8 +311,8 @@ fn insert_tx_displaces_txouts() {
            vout: 0,
        },
        TxOut {
-            value: Amount::from_sat(1_000_000_000),
-            script_pubkey: ScriptBuf::new(),
+            value: 1_000_000_000,
+            script_pubkey: ScriptBuf::default(),
        },
    );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-    let mut graph = TxGraph::<BlockId>::new([
+    let mut graph = TxGraph::<BlockId>::new(vec![
        tx_a0.clone(),
        tx_b0.clone(),
        tx_b1.clone(),
@@ -669,17 +664,17 @@ fn test_walk_ancestors() {

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

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

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

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

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

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

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

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

@@ -825,7 +814,7 @@ fn test_descendants_no_repeat() {
                previous_output: OutPoint::new(h!("tx_does_not_exist"), v),
                ..TxIn::default()
            }],
-            output: vec![TxOut::NULL],
+            output: vec![TxOut::default()],
            ..common::new_tx(v)
        })
        .collect::<Vec<_>>();
@@ -872,11 +861,11 @@ fn test_chain_spends() {
        input: vec![],
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(20_000),
+                value: 20_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -891,11 +880,11 @@ fn test_chain_spends() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(5_000),
+                value: 5_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(5_000),
+                value: 5_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -910,11 +899,11 @@ fn test_chain_spends() {
        }],
        output: vec![
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
            TxOut {
-                value: Amount::from_sat(10_000),
+                value: 10_000,
                script_pubkey: ScriptBuf::new(),
            },
        ],
@@ -1060,31 +1049,136 @@ fn test_changeset_last_seen_append() {
 }

 #[test]
-fn update_last_seen_unconfirmed() {
-    let mut graph = TxGraph::<()>::default();
-    let tx = new_tx(0);
-    let txid = tx.txid();
+fn test_missing_blocks() {
+    /// An anchor implementation for testing, made up of `(the_anchor_block, random_data)`.
+    #[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, core::hash::Hash)]
+    struct TestAnchor(BlockId);

-    // insert a new tx
-    // initially we have a last_seen of 0, and no anchors
-    let _ = graph.insert_tx(tx);
-    let tx = graph.full_txs().next().unwrap();
-    assert_eq!(tx.last_seen_unconfirmed, 0);
-    assert!(tx.anchors.is_empty());
+    impl Anchor for TestAnchor {
+        fn anchor_block(&self) -> BlockId {
+            self.0
+        }
+    }

-    // higher timestamp should update last seen
-    let changeset = graph.update_last_seen_unconfirmed(2);
-    assert_eq!(changeset.last_seen.get(&txid).unwrap(), &2);
+    struct Scenario<'a> {
+        name: &'a str,
+        graph: TxGraph<TestAnchor>,
+        chain: LocalChain,
+        exp_heights: &'a [u32],
+    }

-    // lower timestamp has no effect
-    let changeset = graph.update_last_seen_unconfirmed(1);
-    assert!(changeset.last_seen.is_empty());
+    const fn new_anchor(height: u32, hash: BlockHash) -> TestAnchor {
+        TestAnchor(BlockId { height, hash })
+    }

-    // once anchored, last seen is not updated
-    let _ = graph.insert_anchor(txid, ());
-    let changeset = graph.update_last_seen_unconfirmed(4);
-    assert!(changeset.is_empty());
-    assert_eq!(graph.full_txs().next().unwrap().last_seen_unconfirmed, 2);
+    fn new_scenario<'a>(
+        name: &'a str,
+        graph_anchors: &'a [(Txid, TestAnchor)],
+        chain: &'a [(u32, BlockHash)],
+        exp_heights: &'a [u32],
+    ) -> Scenario<'a> {
+        Scenario {
+            name,
+            graph: {
+                let mut g = TxGraph::default();
+                for (txid, anchor) in graph_anchors {
+                    let _ = g.insert_anchor(*txid, anchor.clone());
+                }
+                g
+            },
+            chain: {
+                let (mut c, _) = LocalChain::from_genesis_hash(h!("genesis"));
+                for (height, hash) in chain {
+                    let _ = c.insert_block(BlockId {
+                        height: *height,
+                        hash: *hash,
+                    });
+                }
+                c
+            },
+            exp_heights,
+        }
+    }
+
+    fn run(scenarios: &[Scenario]) {
+        for scenario in scenarios {
+            let Scenario {
+                name,
+                graph,
+                chain,
+                exp_heights,
+            } = scenario;
+
+            let heights = graph.missing_heights(chain).collect::<Vec<_>>();
+            assert_eq!(&heights, exp_heights, "scenario: {}", name);
+        }
+    }
+
+    run(&[
+        new_scenario(
+            "2 txs with the same anchor (2:B) which is missing from chain",
+            &[
+                (h!("tx_1"), new_anchor(2, h!("B"))),
+                (h!("tx_2"), new_anchor(2, h!("B"))),
+            ],
+            &[(1, h!("A")), (3, h!("C"))],
+            &[2],
+        ),
+        new_scenario(
+            "2 txs with different anchors at the same height, one of the anchors is missing",
+            &[
+                (h!("tx_1"), new_anchor(2, h!("B1"))),
+                (h!("tx_2"), new_anchor(2, h!("B2"))),
+            ],
+            &[(1, h!("A")), (2, h!("B1"))],
+            &[],
+        ),
+        new_scenario(
+            "tx with 2 anchors of same height which are missing from the chain",
+            &[
+                (h!("tx"), new_anchor(3, h!("C1"))),
+                (h!("tx"), new_anchor(3, h!("C2"))),
+            ],
+            &[(1, h!("A")), (4, h!("D"))],
+            &[3],
+        ),
+        new_scenario(
+            "tx with 2 anchors at the same height, chain has this height but does not match either anchor",
+            &[
+                (h!("tx"), new_anchor(4, h!("D1"))),
+                (h!("tx"), new_anchor(4, h!("D2"))),
+            ],
+            &[(4, h!("D3")), (5, h!("E"))],
+            &[],
+        ),
+        new_scenario(
+            "tx with 2 anchors at different heights, one anchor exists in chain, should return nothing",
+            &[
+                (h!("tx"), new_anchor(3, h!("C"))),
+                (h!("tx"), new_anchor(4, h!("D"))),
+            ],
+            &[(4, h!("D")), (5, h!("E"))],
+            &[],
+        ),
+        new_scenario(
+            "tx with 2 anchors at different heights, first height is already in chain with different hash, iterator should only return 2nd height",
+            &[
+                (h!("tx"), new_anchor(5, h!("E1"))),
+                (h!("tx"), new_anchor(6, h!("F1"))),
+            ],
+            &[(4, h!("D")), (5, h!("E")), (7, h!("G"))],
+            &[6],
+        ),
+        new_scenario(
+            "tx with 2 anchors at different heights, neither height is in chain, both heights should be returned",
+            &[
+                (h!("tx"), new_anchor(3, h!("C"))),
+                (h!("tx"), new_anchor(4, h!("D"))),
+            ],
+            &[(1, h!("A")), (2, h!("B"))],
+            &[3, 4],
+        ),
+    ]);
 }

 #[test]
--- a/crates/electrum/Cargo.toml
+++ b/crates/electrum/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_electrum"
-version = "0.12.0"
+version = "0.9.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -12,11 +12,6 @@ readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bdk_chain = { path = "../chain", version = "0.13.0", default-features = false }
-electrum-client = { version = "0.19" }
+bdk_chain = { path = "../chain", version = "0.11.0", default-features = false }
+electrum-client = { version = "0.18" }
 #rustls = { version = "=0.21.1", optional = true, features = ["dangerous_configuration"] }
-
-[dev-dependencies]
-bdk_testenv = { path = "../testenv", default-features = false }
-electrsd = { version= "0.27.1", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
-anyhow = "1"
--- a/crates/electrum/src/electrum_ext.rs
+++ b/crates/electrum/src/electrum_ext.rs
@@ -1,6 +1,6 @@
 use bdk_chain::{
    bitcoin::{OutPoint, ScriptBuf, Transaction, Txid},
-    local_chain::CheckPoint,
+    local_chain::{self, CheckPoint},
    tx_graph::{self, TxGraph},
    Anchor, BlockId, ConfirmationHeightAnchor, ConfirmationTimeHeightAnchor,
 };
@@ -40,11 +40,15 @@ impl RelevantTxids {
    pub fn into_tx_graph(
        self,
        client: &Client,
+        seen_at: Option<u64>,
        missing: Vec<Txid>,
    ) -> Result<TxGraph<ConfirmationHeightAnchor>, Error> {
        let new_txs = client.batch_transaction_get(&missing)?;
        let mut graph = TxGraph::<ConfirmationHeightAnchor>::new(new_txs);
        for (txid, anchors) in self.0 {
+            if let Some(seen_at) = seen_at {
+                let _ = graph.insert_seen_at(txid, seen_at);
+            }
            for anchor in anchors {
                let _ = graph.insert_anchor(txid, anchor);
            }
@@ -63,9 +67,10 @@ impl RelevantTxids {
    pub fn into_confirmation_time_tx_graph(
        self,
        client: &Client,
+        seen_at: Option<u64>,
        missing: Vec<Txid>,
    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error> {
-        let graph = self.into_tx_graph(client, missing)?;
+        let graph = self.into_tx_graph(client, seen_at, missing)?;

        let relevant_heights = {
            let mut visited_heights = HashSet::new();
@@ -124,7 +129,7 @@ impl RelevantTxids {
 #[derive(Debug)]
 pub struct ElectrumUpdate {
    /// Chain update
-    pub chain_update: CheckPoint,
+    pub chain_update: local_chain::Update,
    /// Transaction updates from electrum
    pub relevant_txids: RelevantTxids,
 }
@@ -184,7 +189,7 @@ impl<A: ElectrumApi> ElectrumExt for A {
    ) -> Result<(ElectrumUpdate, BTreeMap<K, u32>), Error> {
        let mut request_spks = keychain_spks
            .into_iter()
-            .map(|(k, s)| (k, s.into_iter()))
+            .map(|(k, s)| (k.clone(), s.into_iter()))
            .collect::<BTreeMap<K, _>>();
        let mut scanned_spks = BTreeMap::<(K, u32), (ScriptBuf, bool)>::new();

@@ -232,7 +237,10 @@ impl<A: ElectrumApi> ElectrumExt for A {
                continue; // reorg
            }

-            let chain_update = tip;
+            let chain_update = local_chain::Update {
+                tip,
+                introduce_older_blocks: true,
+            };

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

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

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

 [features]
-default = ["std", "async-https", "blocking-https-rustls"]
+default = ["std", "async-https", "blocking"]
 std = ["bdk_chain/std"]
 async = ["async-trait", "futures", "esplora-client/async"]
 async-https = ["async", "esplora-client/async-https"]
 async-https-rustls = ["async", "esplora-client/async-https-rustls"]
 blocking = ["esplora-client/blocking"]
-blocking-https-rustls = ["esplora-client/blocking-https-rustls"]
--- a/crates/esplora/src/async_ext.rs
+++ b/crates/esplora/src/async_ext.rs
@@ -1,15 +1,12 @@
-use std::collections::BTreeSet;
-
 use async_trait::async_trait;
-use bdk_chain::spk_client::{FullScanRequest, FullScanResult, SyncRequest, SyncResult};
-use bdk_chain::Anchor;
+use bdk_chain::collections::btree_map;
 use bdk_chain::{
    bitcoin::{BlockHash, OutPoint, ScriptBuf, TxOut, Txid},
    collections::BTreeMap,
-    local_chain::CheckPoint,
+    local_chain::{self, CheckPoint},
    BlockId, ConfirmationTimeHeightAnchor, TxGraph,
 };
-use esplora_client::{Amount, TxStatus};
+use esplora_client::TxStatus;
 use futures::{stream::FuturesOrdered, TryStreamExt};

 use crate::anchor_from_status;
@@ -25,41 +22,49 @@ type Error = Box<esplora_client::Error>;
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait EsploraAsyncExt {
-    /// Scan keychain scripts for transactions against Esplora, returning an update that can be
-    /// applied to the receiving structures.
+    /// Prepare a [`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
+    async fn update_local_chain(
+        &self,
+        local_tip: CheckPoint,
+        request_heights: impl IntoIterator<IntoIter = impl Iterator<Item = u32> + Send> + Send,
+    ) -> Result<local_chain::Update, Error>;
+
+    /// Full scan the keychain scripts specified with the blockchain (via an Esplora client) and
+    /// returns a [`TxGraph`] and a map of last active indices.
    ///
-    /// * `local_tip`: the previously seen tip from [`LocalChain::tip`].
    /// * `keychain_spks`: keychains that we want to scan transactions for
    ///
-    /// The full scan for each keychain stops after a gap of `stop_gap` script pubkeys with no
-    /// associated transactions. `parallel_requests` specifies the max number of HTTP requests to
-    /// make in parallel.
-    ///
-    /// ## Note
-    ///
-    /// `stop_gap` is defined as "the maximum number of consecutive unused addresses".
-    /// For example, with a `stop_gap` of  3, `full_scan` will keep scanning
-    /// until it encounters 3 consecutive script pubkeys with no associated transactions.
-    ///
-    /// This follows the same approach as other Bitcoin-related software,
-    /// such as [Electrum](https://electrum.readthedocs.io/en/latest/faq.html#what-is-the-gap-limit),
-    /// [BTCPay Server](https://docs.btcpayserver.org/FAQ/Wallet/#the-gap-limit-problem),
-    /// and [Sparrow](https://www.sparrowwallet.com/docs/faq.html#ive-restored-my-wallet-but-some-of-my-funds-are-missing).
-    ///
-    /// A `stop_gap` of 0 will be treated as a `stop_gap` of 1.
-    ///
-    /// [`LocalChain::tip`]: bdk_chain::local_chain::LocalChain::tip
+    /// 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.
    async fn full_scan<K: Ord + Clone + Send>(
        &self,
-        request: FullScanRequest<K>,
+        keychain_spks: BTreeMap<
+            K,
+            impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send> + Send,
+        >,
        stop_gap: usize,
        parallel_requests: usize,
-    ) -> Result<FullScanResult<K>, Error>;
+    ) -> 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`].
    ///
-    /// * `local_tip`: the previously seen tip from [`LocalChain::tip`].
    /// * `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
@@ -68,214 +73,209 @@ pub trait EsploraAsyncExt {
    /// 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.
    ///
-    /// [`LocalChain::tip`]: bdk_chain::local_chain::LocalChain::tip
    /// [`full_scan`]: EsploraAsyncExt::full_scan
    async fn sync(
        &self,
-        request: SyncRequest,
+        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<SyncResult, Error>;
+    ) -> Result<TxGraph<ConfirmationTimeHeightAnchor>, Error>;
 }

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl EsploraAsyncExt for esplora_client::AsyncClient {
+    async fn update_local_chain(
+        &self,
+        local_tip: CheckPoint,
+        request_heights: impl IntoIterator<IntoIter = impl Iterator<Item = u32> + Send> + Send,
+    ) -> Result<local_chain::Update, Error> {
+        // 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");
+
+        // Fetch blocks of heights that the caller is interested in, skipping blocks that are
+        // already fetched when constructing `fetched_blocks`.
+        for height in request_heights {
+            // do not fetch blocks higher than remote tip
+            if height > new_tip_height {
+                continue;
+            }
+            // 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?);
+            }
+        }
+
+        // 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;
+            }
+
+            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?)
+                }
+            };
+
+            // We have found point of agreement so the update will connect!
+            if fetched_hash == local_hash {
+                break;
+            }
+        }
+
+        Ok(local_chain::Update {
+            tip: CheckPoint::from_block_ids(fetched_blocks.into_iter().map(BlockId::from))
+                .expect("must be in height order"),
+            introduce_older_blocks: true,
+        })
+    }
+
    async fn full_scan<K: Ord + Clone + Send>(
        &self,
-        request: FullScanRequest<K>,
+        keychain_spks: BTreeMap<
+            K,
+            impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send> + Send,
+        >,
        stop_gap: usize,
        parallel_requests: usize,
-    ) -> Result<FullScanResult<K>, Error> {
-        let latest_blocks = fetch_latest_blocks(self).await?;
-        let (graph_update, last_active_indices) = full_scan_for_index_and_graph(
-            self,
-            request.spks_by_keychain,
-            stop_gap,
-            parallel_requests,
-        )
-        .await?;
-        let chain_update = chain_update(
-            self,
-            &latest_blocks,
-            &request.chain_tip,
-            graph_update.all_anchors(),
-        )
-        .await?;
-        Ok(FullScanResult {
-            chain_update,
-            graph_update,
-            last_active_indices,
-        })
+    ) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error> {
+        type TxsOfSpkIndex = (u32, Vec<esplora_client::Tx>);
+        let parallel_requests = Ord::max(parallel_requests, 1);
+        let mut graph = TxGraph::<ConfirmationTimeHeightAnchor>::default();
+        let mut last_active_indexes = BTreeMap::<K, u32>::new();
+
+        for (keychain, spks) in keychain_spks {
+            let mut spks = spks.into_iter();
+            let mut last_index = Option::<u32>::None;
+            let mut last_active_index = Option::<u32>::None;
+
+            loop {
+                let handles = spks
+                    .by_ref()
+                    .take(parallel_requests)
+                    .map(|(spk_index, spk)| {
+                        let client = self.clone();
+                        async move {
+                            let mut last_seen = None;
+                            let mut spk_txs = Vec::new();
+                            loop {
+                                let txs = client.scripthash_txs(&spk, last_seen).await?;
+                                let tx_count = txs.len();
+                                last_seen = txs.last().map(|tx| tx.txid);
+                                spk_txs.extend(txs);
+                                if tx_count < 25 {
+                                    break Result::<_, Error>::Ok((spk_index, spk_txs));
+                                }
+                            }
+                        }
+                    })
+                    .collect::<FuturesOrdered<_>>();
+
+                if handles.is_empty() {
+                    break;
+                }
+
+                for (index, txs) in handles.try_collect::<Vec<TxsOfSpkIndex>>().await? {
+                    last_index = Some(index);
+                    if !txs.is_empty() {
+                        last_active_index = Some(index);
+                    }
+                    for tx in txs {
+                        let _ = graph.insert_tx(tx.to_tx());
+                        if let Some(anchor) = anchor_from_status(&tx.status) {
+                            let _ = graph.insert_anchor(tx.txid, anchor);
+                        }
+
+                        let previous_outputs = tx.vin.iter().filter_map(|vin| {
+                            let prevout = vin.prevout.as_ref()?;
+                            Some((
+                                OutPoint {
+                                    txid: vin.txid,
+                                    vout: vin.vout,
+                                },
+                                TxOut {
+                                    script_pubkey: prevout.scriptpubkey.clone(),
+                                    value: prevout.value,
+                                },
+                            ))
+                        });
+
+                        for (outpoint, txout) in previous_outputs {
+                            let _ = graph.insert_txout(outpoint, txout);
+                        }
+                    }
+                }
+
+                let last_index = last_index.expect("Must be set since handles wasn't empty.");
+                let past_gap_limit = if let Some(i) = last_active_index {
+                    last_index > i.saturating_add(stop_gap as u32)
+                } else {
+                    last_index >= stop_gap as u32
+                };
+                if past_gap_limit {
+                    break;
+                }
+            }
+
+            if let Some(last_active_index) = last_active_index {
+                last_active_indexes.insert(keychain, last_active_index);
+            }
+        }
+
+        Ok((graph, last_active_indexes))
    }

    async fn sync(
        &self,
-        request: SyncRequest,
+        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<SyncResult, Error> {
-        let latest_blocks = fetch_latest_blocks(self).await?;
-        let graph_update = sync_for_index_and_graph(
-            self,
-            request.spks,
-            request.txids,
-            request.outpoints,
-            parallel_requests,
-        )
-        .await?;
-        let chain_update = chain_update(
-            self,
-            &latest_blocks,
-            &request.chain_tip,
-            graph_update.all_anchors(),
-        )
-        .await?;
-        Ok(SyncResult {
-            chain_update,
-            graph_update,
-        })
-    }
-}
-
-/// Fetch latest blocks from Esplora in an atomic call.
-///
-/// We want to do this before fetching transactions and anchors as we cannot fetch latest blocks AND
-/// transactions atomically, and the checkpoint tip is used to determine last-scanned block (for
-/// block-based chain-sources). Therefore it's better to be conservative when setting the tip (use
-/// an earlier tip rather than a later tip) otherwise the caller may accidentally skip blocks when
-/// alternating between chain-sources.
-async fn fetch_latest_blocks(
-    client: &esplora_client::AsyncClient,
-) -> Result<BTreeMap<u32, BlockHash>, Error> {
-    Ok(client
-        .get_blocks(None)
-        .await?
-        .into_iter()
-        .map(|b| (b.time.height, b.id))
-        .collect())
-}
-
-/// Used instead of [`esplora_client::BlockingClient::get_block_hash`].
-///
-/// This first checks the previously fetched `latest_blocks` before fetching from Esplora again.
-async fn fetch_block(
-    client: &esplora_client::AsyncClient,
-    latest_blocks: &BTreeMap<u32, BlockHash>,
-    height: u32,
-) -> Result<Option<BlockHash>, Error> {
-    if let Some(&hash) = latest_blocks.get(&height) {
-        return Ok(Some(hash));
-    }
-
-    // We avoid fetching blocks higher than previously fetched `latest_blocks` as the local chain
-    // tip is used to signal for the last-synced-up-to-height.
-    let &tip_height = latest_blocks
-        .keys()
-        .last()
-        .expect("must have atleast one entry");
-    if height > tip_height {
-        return Ok(None);
-    }
-
-    Ok(Some(client.get_block_hash(height).await?))
-}
-
-/// Create the [`local_chain::Update`].
-///
-/// We want to have a corresponding checkpoint per anchor height. However, checkpoints fetched
-/// should not surpass `latest_blocks`.
-async fn chain_update<A: Anchor>(
-    client: &esplora_client::AsyncClient,
-    latest_blocks: &BTreeMap<u32, BlockHash>,
-    local_tip: &CheckPoint,
-    anchors: &BTreeSet<(A, Txid)>,
-) -> Result<CheckPoint, Error> {
-    let mut point_of_agreement = None;
-    let mut conflicts = vec![];
-    for local_cp in local_tip.iter() {
-        let remote_hash = match fetch_block(client, latest_blocks, local_cp.height()).await? {
-            Some(hash) => hash,
-            None => continue,
-        };
-        if remote_hash == local_cp.hash() {
-            point_of_agreement = Some(local_cp.clone());
-            break;
-        } else {
-            // it is not strictly necessary to include all the conflicted heights (we do need the
-            // first one) but it seems prudent to make sure the updated chain's heights are a
-            // superset of the existing chain after update.
-            conflicts.push(BlockId {
-                height: local_cp.height(),
-                hash: remote_hash,
-            });
-        }
-    }
-
-    let mut tip = point_of_agreement.expect("remote esplora should have same genesis block");
-
-    tip = tip
-        .extend(conflicts.into_iter().rev())
-        .expect("evicted are in order");
-
-    for anchor in anchors {
-        let height = anchor.0.anchor_block().height;
-        if tip.get(height).is_none() {
-            let hash = match fetch_block(client, latest_blocks, height).await? {
-                Some(hash) => hash,
-                None => continue,
-            };
-            tip = tip.insert(BlockId { height, hash });
-        }
-    }
-
-    // insert the most recent blocks at the tip to make sure we update the tip and make the update
-    // robust.
-    for (&height, &hash) in latest_blocks.iter() {
-        tip = tip.insert(BlockId { height, hash });
-    }
-
-    Ok(tip)
-}
-
-/// This performs a full scan to get an update for the [`TxGraph`] and
-/// [`KeychainTxOutIndex`](bdk_chain::keychain::KeychainTxOutIndex).
-async fn full_scan_for_index_and_graph<K: Ord + Clone + Send>(
-    client: &esplora_client::AsyncClient,
-    keychain_spks: BTreeMap<
-        K,
-        impl IntoIterator<IntoIter = impl Iterator<Item = (u32, ScriptBuf)> + Send> + Send,
-    >,
-    stop_gap: usize,
-    parallel_requests: usize,
-) -> Result<(TxGraph<ConfirmationTimeHeightAnchor>, BTreeMap<K, u32>), Error> {
-    type TxsOfSpkIndex = (u32, Vec<esplora_client::Tx>);
-    let parallel_requests = Ord::max(parallel_requests, 1);
-    let mut graph = TxGraph::<ConfirmationTimeHeightAnchor>::default();
-    let mut last_active_indexes = BTreeMap::<K, u32>::new();
-
-    for (keychain, spks) in keychain_spks {
-        let mut spks = spks.into_iter();
-        let mut last_index = Option::<u32>::None;
-        let mut last_active_index = Option::<u32>::None;
+    ) -> 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 = spks
+            let handles = txids
                .by_ref()
                .take(parallel_requests)
-                .map(|(spk_index, spk)| {
-                    let client = client.clone();
-                    async move {
-                        let mut last_seen = None;
-                        let mut spk_txs = Vec::new();
-                        loop {
-                            let txs = client.scripthash_txs(&spk, last_seen).await?;
-                            let tx_count = txs.len();
-                            last_seen = txs.last().map(|tx| tx.txid);
-                            spk_txs.extend(txs);
-                            if tx_count < 25 {
-                                break Result::<_, Error>::Ok((spk_index, spk_txs));
-                            }
-                        }
-                    }
+                .filter(|&txid| graph.get_tx(txid).is_none())
+                .map(|txid| {
+                    let client = self.clone();
+                    async move { client.get_tx_status(&txid).await.map(|s| (txid, s)) }
                })
                .collect::<FuturesOrdered<_>>();

@@ -283,315 +283,38 @@ async fn full_scan_for_index_and_graph<K: Ord + Clone + Send>(
                break;
            }

-            for (index, txs) in handles.try_collect::<Vec<TxsOfSpkIndex>>().await? {
-                last_index = Some(index);
-                if !txs.is_empty() {
-                    last_active_index = Some(index);
+            for (txid, status) in handles.try_collect::<Vec<(Txid, TxStatus)>>().await? {
+                if let Some(anchor) = anchor_from_status(&status) {
+                    let _ = graph.insert_anchor(txid, anchor);
                }
-                for tx in txs {
-                    let _ = graph.insert_tx(tx.to_tx());
-                    if let Some(anchor) = anchor_from_status(&tx.status) {
-                        let _ = graph.insert_anchor(tx.txid, anchor);
-                    }
+            }
+        }

-                    let previous_outputs = tx.vin.iter().filter_map(|vin| {
-                        let prevout = vin.prevout.as_ref()?;
-                        Some((
-                            OutPoint {
-                                txid: vin.txid,
-                                vout: vin.vout,
-                            },
-                            TxOut {
-                                script_pubkey: prevout.scriptpubkey.clone(),
-                                value: Amount::from_sat(prevout.value),
-                            },
-                        ))
-                    });
-
-                    for (outpoint, txout) in previous_outputs {
-                        let _ = graph.insert_txout(outpoint, txout);
-                    }
+        for op in outpoints.into_iter() {
+            if graph.get_tx(op.txid).is_none() {
+                if let Some(tx) = self.get_tx(&op.txid).await? {
+                    let _ = graph.insert_tx(tx);
+                }
+                let status = self.get_tx_status(&op.txid).await?;
+                if let Some(anchor) = anchor_from_status(&status) {
+                    let _ = graph.insert_anchor(op.txid, anchor);
                }
            }

-            let last_index = last_index.expect("Must be set since handles wasn't empty.");
-            let gap_limit_reached = if let Some(i) = last_active_index {
-                last_index >= i.saturating_add(stop_gap as u32)
-            } else {
-                last_index + 1 >= stop_gap as u32
-            };
-            if gap_limit_reached {
-                break;
-            }
-        }
-
-        if let Some(last_active_index) = last_active_index {
-            last_active_indexes.insert(keychain, last_active_index);
-        }
-    }
-
-    Ok((graph, last_active_indexes))
-}
-
-async fn sync_for_index_and_graph(
-    client: &esplora_client::AsyncClient,
-    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 = full_scan_for_index_and_graph(
-        client,
-        [(
-            (),
-            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
-            .by_ref()
-            .take(parallel_requests)
-            .filter(|&txid| graph.get_tx(txid).is_none())
-            .map(|txid| {
-                let client = client.clone();
-                async move { client.get_tx_status(&txid).await.map(|s| (txid, s)) }
-            })
-            .collect::<FuturesOrdered<_>>();
-
-        if handles.is_empty() {
-            break;
-        }
-
-        for (txid, status) in handles.try_collect::<Vec<(Txid, TxStatus)>>().await? {
-            if let Some(anchor) = anchor_from_status(&status) {
-                let _ = graph.insert_anchor(txid, anchor);
-            }
-        }
-    }
-
-    for op in outpoints.into_iter() {
-        if graph.get_tx(op.txid).is_none() {
-            if let Some(tx) = client.get_tx(&op.txid).await? {
-                let _ = graph.insert_tx(tx);
-            }
-            let status = client.get_tx_status(&op.txid).await?;
-            if let Some(anchor) = anchor_from_status(&status) {
-                let _ = graph.insert_anchor(op.txid, anchor);
-            }
-        }
-
-        if let Some(op_status) = client.get_output_status(&op.txid, op.vout as _).await? {
-            if let Some(txid) = op_status.txid {
-                if graph.get_tx(txid).is_none() {
-                    if let Some(tx) = client.get_tx(&txid).await? {
-                        let _ = graph.insert_tx(tx);
-                    }
-                    let status = client.get_tx_status(&txid).await?;
-                    if let Some(anchor) = anchor_from_status(&status) {
-                        let _ = graph.insert_anchor(txid, anchor);
+            if let Some(op_status) = self.get_output_status(&op.txid, op.vout as _).await? {
+                if let Some(txid) = op_status.txid {
+                    if graph.get_tx(txid).is_none() {
+                        if let Some(tx) = self.get_tx(&txid).await? {
+                            let _ = graph.insert_tx(tx);
+                        }
+                        let status = self.get_tx_status(&txid).await?;
+                        if let Some(anchor) = anchor_from_status(&status) {
+                            let _ = graph.insert_anchor(txid, anchor);
+                        }
                    }
                }
            }
        }
-    }
-
-    Ok(graph)
-}
-
-#[cfg(test)]
-mod test {
-    use std::{collections::BTreeSet, time::Duration};
-
-    use bdk_chain::{
-        bitcoin::{hashes::Hash, Txid},
-        local_chain::LocalChain,
-        BlockId,
-    };
-    use bdk_testenv::TestEnv;
-    use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-    use esplora_client::Builder;
-
-    use crate::async_ext::{chain_update, fetch_latest_blocks};
-
-    macro_rules! h {
-        ($index:literal) => {{
-            bdk_chain::bitcoin::hashes::Hash::hash($index.as_bytes())
-        }};
-    }
-
-    /// Ensure that update does not remove heights (from original), and all anchor heights are included.
-    #[tokio::test]
-    pub async fn test_finalize_chain_update() -> anyhow::Result<()> {
-        struct TestCase<'a> {
-            name: &'a str,
-            /// Initial blockchain height to start the env with.
-            initial_env_height: u32,
-            /// Initial checkpoint heights to start with.
-            initial_cps: &'a [u32],
-            /// The final blockchain height of the env.
-            final_env_height: u32,
-            /// The anchors to test with: `(height, txid)`. Only the height is provided as we can fetch
-            /// the blockhash from the env.
-            anchors: &'a [(u32, Txid)],
-        }
-
-        let test_cases = [
-            TestCase {
-                name: "chain_extends",
-                initial_env_height: 60,
-                initial_cps: &[59, 60],
-                final_env_height: 90,
-                anchors: &[],
-            },
-            TestCase {
-                name: "introduce_older_heights",
-                initial_env_height: 50,
-                initial_cps: &[10, 15],
-                final_env_height: 50,
-                anchors: &[(11, h!("A")), (14, h!("B"))],
-            },
-            TestCase {
-                name: "introduce_older_heights_after_chain_extends",
-                initial_env_height: 50,
-                initial_cps: &[10, 15],
-                final_env_height: 100,
-                anchors: &[(11, h!("A")), (14, h!("B"))],
-            },
-        ];
-
-        for (i, t) in test_cases.into_iter().enumerate() {
-            println!("[{}] running test case: {}", i, t.name);
-
-            let env = TestEnv::new()?;
-            let base_url = format!("http://{}", &env.electrsd.esplora_url.clone().unwrap());
-            let client = Builder::new(base_url.as_str()).build_async()?;
-
-            // set env to `initial_env_height`
-            if let Some(to_mine) = t
-                .initial_env_height
-                .checked_sub(env.make_checkpoint_tip().height())
-            {
-                env.mine_blocks(to_mine as _, None)?;
-            }
-            while client.get_height().await? < t.initial_env_height {
-                std::thread::sleep(Duration::from_millis(10));
-            }
-
-            // craft initial `local_chain`
-            let local_chain = {
-                let (mut chain, _) = LocalChain::from_genesis_hash(env.genesis_hash()?);
-                // force `chain_update_blocking` to add all checkpoints in `t.initial_cps`
-                let anchors = t
-                    .initial_cps
-                    .iter()
-                    .map(|&height| -> anyhow::Result<_> {
-                        Ok((
-                            BlockId {
-                                height,
-                                hash: env.bitcoind.client.get_block_hash(height as _)?,
-                            },
-                            Txid::all_zeros(),
-                        ))
-                    })
-                    .collect::<anyhow::Result<BTreeSet<_>>>()?;
-                let update = chain_update(
-                    &client,
-                    &fetch_latest_blocks(&client).await?,
-                    &chain.tip(),
-                    &anchors,
-                )
-                .await?;
-                chain.apply_update(update)?;
-                chain
-            };
-            println!("local chain height: {}", local_chain.tip().height());
-
-            // extend env chain
-            if let Some(to_mine) = t
-                .final_env_height
-                .checked_sub(env.make_checkpoint_tip().height())
-            {
-                env.mine_blocks(to_mine as _, None)?;
-            }
-            while client.get_height().await? < t.final_env_height {
-                std::thread::sleep(Duration::from_millis(10));
-            }
-
-            // craft update
-            let update = {
-                let anchors = t
-                    .anchors
-                    .iter()
-                    .map(|&(height, txid)| -> anyhow::Result<_> {
-                        Ok((
-                            BlockId {
-                                height,
-                                hash: env.bitcoind.client.get_block_hash(height as _)?,
-                            },
-                            txid,
-                        ))
-                    })
-                    .collect::<anyhow::Result<_>>()?;
-                chain_update(
-                    &client,
-                    &fetch_latest_blocks(&client).await?,
-                    &local_chain.tip(),
-                    &anchors,
-                )
-                .await?
-            };
-
-            // apply update
-            let mut updated_local_chain = local_chain.clone();
-            updated_local_chain.apply_update(update)?;
-            println!(
-                "updated local chain height: {}",
-                updated_local_chain.tip().height()
-            );
-
-            assert!(
-                {
-                    let initial_heights = local_chain
-                        .iter_checkpoints()
-                        .map(|cp| cp.height())
-                        .collect::<BTreeSet<_>>();
-                    let updated_heights = updated_local_chain
-                        .iter_checkpoints()
-                        .map(|cp| cp.height())
-                        .collect::<BTreeSet<_>>();
-                    updated_heights.is_superset(&initial_heights)
-                },
-                "heights from the initial chain must all be in the updated chain",
-            );
-
-            assert!(
-                {
-                    let exp_anchor_heights = t
-                        .anchors
-                        .iter()
-                        .map(|(h, _)| *h)
-                        .chain(t.initial_cps.iter().copied())
-                        .collect::<BTreeSet<_>>();
-                    let anchor_heights = updated_local_chain
-                        .iter_checkpoints()
-                        .map(|cp| cp.height())
-                        .collect::<BTreeSet<_>>();
-                    anchor_heights.is_superset(&exp_anchor_heights)
-                },
-                "anchor heights must all be in updated chain",
-            );
-        }
-
-        Ok(())
+        Ok(graph)
    }
 }
--- a/crates/esplora/src/blocking_ext.rs
+++ b/crates/esplora/src/blocking_ext.rs
--- a/crates/esplora/tests/async_ext.rs
+++ b/crates/esplora/tests/async_ext.rs
@@ -1,22 +1,68 @@
-use bdk_chain::spk_client::{FullScanRequest, SyncRequest};
 use bdk_esplora::EsploraAsyncExt;
-use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use esplora_client::{self, Builder};
-use std::collections::{BTreeSet, HashSet};
+use electrsd::bitcoind::{self, anyhow, BitcoinD};
+use electrsd::{Conf, ElectrsD};
+use esplora_client::{self, AsyncClient, Builder};
+use std::collections::{BTreeMap, HashSet};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;

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

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

-    // use a full checkpoint linked list (since this is not what we are testing)
-    let cp_tip = env.make_checkpoint_tip();
+    let graph_update = env
+        .client
+        .sync(
+            misc_spks.into_iter(),
+            vec![].into_iter(),
+            vec![].into_iter(),
+            1,
+        )
+        .await?;

-    let sync_update = {
-        let request = SyncRequest::from_chain_tip(cp_tip.clone()).set_spks(misc_spks);
-        client.sync(request, 1).await?
-    };
-
-    assert!(
-        {
-            let update_cps = sync_update
-                .chain_update
-                .iter()
-                .map(|cp| cp.block_id())
-                .collect::<BTreeSet<_>>();
-            let superset_cps = cp_tip
-                .iter()
-                .map(|cp| cp.block_id())
-                .collect::<BTreeSet<_>>();
-            superset_cps.is_superset(&update_cps)
-        },
-        "update should not alter original checkpoint tip since we already started with all checkpoints",
-    );
-
-    let graph_update = sync_update.graph_update;
    // Check to see if we have the floating txouts available from our two created transactions'
    // previous outputs in order to calculate transaction fees.
    for tx in graph_update.full_txs() {
        // Retrieve the calculated fee from `TxGraph`, which will panic if we do not have the
        // floating txouts available from the transactions' previous outputs.
-        let fee = graph_update.calculate_fee(&tx.tx).expect("Fee must exist");
+        let fee = graph_update.calculate_fee(tx.tx).expect("Fee must exist");

        // Retrieve the fee in the transaction data from `bitcoind`.
        let tx_fee = env
@@ -108,12 +139,10 @@ pub async fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    Ok(())
 }

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

    // Now let's test the gap limit. First of all get a chain of 10 addresses.
@@ -138,6 +167,8 @@ pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        .enumerate()
        .map(|(i, addr)| (i as u32, addr.script_pubkey()))
        .collect();
+    let mut keychains = BTreeMap::new();
+    keychains.insert(0, spks);

    // Then receive coins on the 4th address.
    let txid_4th_addr = env.bitcoind.client.send_to_address(
@@ -151,37 +182,18 @@ pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().await.unwrap() < 103 {
+    while env.client.get_height().await.unwrap() < 103 {
        sleep(Duration::from_millis(10))
    }

-    // use a full checkpoint linked list (since this is not what we are testing)
-    let cp_tip = env.make_checkpoint_tip();
-
-    // A scan with a gap limit of 3 won't find the transaction, but a scan with a gap limit of 4
+    // A scan with a gap limit of 2 won't find the transaction, but a scan with a gap limit of 3
    // will.
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 3, 1).await?
-    };
-    assert!(full_scan_update.graph_update.full_txs().next().is_none());
-    assert!(full_scan_update.last_active_indices.is_empty());
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 4, 1).await?
-    };
-    assert_eq!(
-        full_scan_update
-            .graph_update
-            .full_txs()
-            .next()
-            .unwrap()
-            .txid,
-        txid_4th_addr
-    );
-    assert_eq!(full_scan_update.last_active_indices[&0], 3);
+    let (graph_update, active_indices) = env.client.full_scan(keychains.clone(), 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?;
+    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
+    assert_eq!(active_indices[&0], 3);

    // Now receive a coin on the last address.
    let txid_last_addr = env.bitcoind.client.send_to_address(
@@ -195,38 +207,22 @@ pub async fn test_async_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().await.unwrap() < 104 {
+    while env.client.get_height().await.unwrap() < 104 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with gap limit 5 won't find the second transaction, but a scan with gap limit 6 will.
+    // A scan with gap limit 4 won't find the second transaction, but a scan with gap limit 5 will.
    // The last active indice won't be updated in the first case but will in the second one.
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 5, 1).await?
-    };
-    let txs: HashSet<_> = full_scan_update
-        .graph_update
-        .full_txs()
-        .map(|tx| tx.txid)
-        .collect();
+    let (graph_update, active_indices) = env.client.full_scan(keychains.clone(), 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!(full_scan_update.last_active_indices[&0], 3);
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 6, 1).await?
-    };
-    let txs: HashSet<_> = full_scan_update
-        .graph_update
-        .full_txs()
-        .map(|tx| tx.txid)
-        .collect();
+    assert_eq!(active_indices[&0], 3);
+    let (graph_update, active_indices) = env.client.full_scan(keychains, 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));
-    assert_eq!(full_scan_update.last_active_indices[&0], 9);
+    assert_eq!(active_indices[&0], 9);

    Ok(())
 }
--- a/crates/esplora/tests/blocking_ext.rs
+++ b/crates/esplora/tests/blocking_ext.rs
@@ -1,22 +1,98 @@
-use bdk_chain::spk_client::{FullScanRequest, SyncRequest};
+use bdk_chain::local_chain::LocalChain;
+use bdk_chain::BlockId;
 use bdk_esplora::EsploraExt;
-use electrsd::bitcoind::anyhow;
 use electrsd::bitcoind::bitcoincore_rpc::RpcApi;
-use esplora_client::{self, Builder};
-use std::collections::{BTreeSet, HashSet};
+use electrsd::bitcoind::{self, anyhow, BitcoinD};
+use electrsd::{Conf, ElectrsD};
+use esplora_client::{self, BlockingClient, Builder};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;

-use bdk_chain::bitcoin::{Address, Amount, Txid};
-use bdk_testenv::TestEnv;
+use bdk_chain::bitcoin::{Address, Amount, BlockHash, Txid};
+
+macro_rules! h {
+    ($index:literal) => {{
+        bdk_chain::bitcoin::hashes::Hash::hash($index.as_bytes())
+    }};
+}
+
+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)]
+    electrsd: ElectrsD,
+    client: BlockingClient,
+}
+
+impl TestEnv {
+    fn new() -> Result<Self, anyhow::Error> {
+        let bitcoind_exe =
+            bitcoind::downloaded_exe_path().expect("bitcoind version feature must be enabled");
+        let bitcoind = BitcoinD::new(bitcoind_exe).unwrap();
+
+        let mut electrs_conf = Conf::default();
+        electrs_conf.http_enabled = true;
+        let electrs_exe =
+            electrsd::downloaded_exe_path().expect("electrs version feature must be enabled");
+        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrs_conf)?;
+
+        let base_url = format!("http://{}", &electrsd.esplora_url.clone().unwrap());
+        let client = Builder::new(base_url.as_str()).build_blocking()?;
+
+        Ok(Self {
+            bitcoind,
+            electrsd,
+            client,
+        })
+    }
+
+    fn 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,
+        address: Option<Address>,
+    ) -> anyhow::Result<Vec<BlockHash>> {
+        let coinbase_address = match address {
+            Some(address) => address,
+            None => self
+                .bitcoind
+                .client
+                .get_new_address(None, None)?
+                .assume_checked(),
+        };
+        let block_hashes = self
+            .bitcoind
+            .client
+            .generate_to_address(count as _, &coinbase_address)?;
+        Ok(block_hashes)
+    }
+}

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

-    // use a full checkpoint linked list (since this is not what we are testing)
-    let cp_tip = env.make_checkpoint_tip();
+    let graph_update = env.client.sync(
+        misc_spks.into_iter(),
+        vec![].into_iter(),
+        vec![].into_iter(),
+        1,
+    )?;

-    let sync_update = {
-        let request = SyncRequest::from_chain_tip(cp_tip.clone()).set_spks(misc_spks);
-        client.sync(request, 1)?
-    };
-
-    assert!(
-        {
-            let update_cps = sync_update
-                .chain_update
-                .iter()
-                .map(|cp| cp.block_id())
-                .collect::<BTreeSet<_>>();
-            let superset_cps = cp_tip
-                .iter()
-                .map(|cp| cp.block_id())
-                .collect::<BTreeSet<_>>();
-            superset_cps.is_superset(&update_cps)
-        },
-        "update should not alter original checkpoint tip since we already started with all checkpoints",
-    );
-
-    let graph_update = sync_update.graph_update;
    // Check to see if we have the floating txouts available from our two created transactions'
    // previous outputs in order to calculate transaction fees.
    for tx in graph_update.full_txs() {
        // Retrieve the calculated fee from `TxGraph`, which will panic if we do not have the
        // floating txouts available from the transactions' previous outputs.
-        let fee = graph_update.calculate_fee(&tx.tx).expect("Fee must exist");
+        let fee = graph_update.calculate_fee(tx.tx).expect("Fee must exist");

        // Retrieve the fee in the transaction data from `bitcoind`.
        let tx_fee = env
@@ -109,12 +167,10 @@ pub fn test_update_tx_graph_without_keychain() -> anyhow::Result<()> {
    Ok(())
 }

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

    // Now let's test the gap limit. First of all get a chain of 10 addresses.
@@ -139,6 +195,8 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        .enumerate()
        .map(|(i, addr)| (i as u32, addr.script_pubkey()))
        .collect();
+    let mut keychains = BTreeMap::new();
+    keychains.insert(0, spks);

    // Then receive coins on the 4th address.
    let txid_4th_addr = env.bitcoind.client.send_to_address(
@@ -152,37 +210,18 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().unwrap() < 103 {
+    while env.client.get_height().unwrap() < 103 {
        sleep(Duration::from_millis(10))
    }

-    // use a full checkpoint linked list (since this is not what we are testing)
-    let cp_tip = env.make_checkpoint_tip();
-
-    // A scan with a stop_gap of 3 won't find the transaction, but a scan with a gap limit of 4
+    // A scan with a gap limit of 2 won't find the transaction, but a scan with a gap limit of 3
    // will.
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 3, 1)?
-    };
-    assert!(full_scan_update.graph_update.full_txs().next().is_none());
-    assert!(full_scan_update.last_active_indices.is_empty());
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 4, 1)?
-    };
-    assert_eq!(
-        full_scan_update
-            .graph_update
-            .full_txs()
-            .next()
-            .unwrap()
-            .txid,
-        txid_4th_addr
-    );
-    assert_eq!(full_scan_update.last_active_indices[&0], 3);
+    let (graph_update, active_indices) = env.client.full_scan(keychains.clone(), 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)?;
+    assert_eq!(graph_update.full_txs().next().unwrap().txid, txid_4th_addr);
+    assert_eq!(active_indices[&0], 3);

    // Now receive a coin on the last address.
    let txid_last_addr = env.bitcoind.client.send_to_address(
@@ -196,38 +235,199 @@ pub fn test_update_tx_graph_stop_gap() -> anyhow::Result<()> {
        None,
    )?;
    let _block_hashes = env.mine_blocks(1, None)?;
-    while client.get_height().unwrap() < 104 {
+    while env.client.get_height().unwrap() < 104 {
        sleep(Duration::from_millis(10))
    }

-    // A scan with gap limit 5 won't find the second transaction, but a scan with gap limit 6 will.
+    // A scan with gap limit 4 won't find the second transaction, but a scan with gap limit 5 will.
    // The last active indice won't be updated in the first case but will in the second one.
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 5, 1)?
-    };
-    let txs: HashSet<_> = full_scan_update
-        .graph_update
-        .full_txs()
-        .map(|tx| tx.txid)
-        .collect();
+    let (graph_update, active_indices) = env.client.full_scan(keychains.clone(), 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!(full_scan_update.last_active_indices[&0], 3);
-    let full_scan_update = {
-        let request =
-            FullScanRequest::from_chain_tip(cp_tip.clone()).set_spks_for_keychain(0, spks.clone());
-        client.full_scan(request, 6, 1)?
-    };
-    let txs: HashSet<_> = full_scan_update
-        .graph_update
-        .full_txs()
-        .map(|tx| tx.txid)
-        .collect();
+    assert_eq!(active_indices[&0], 3);
+    let (graph_update, active_indices) = env.client.full_scan(keychains, 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));
-    assert_eq!(full_scan_update.last_active_indices[&0], 9);
+    assert_eq!(active_indices[&0], 9);
+
+    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.10.0"
+version = "0.7.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -11,9 +11,7 @@ authors = ["Bitcoin Dev Kit Developers"]
 readme = "README.md"

 [dependencies]
-anyhow = { version = "1", default-features = false }
-bdk_chain = { path = "../chain", version = "0.13.0", features = [ "serde", "miniscript" ] }
-bdk_persist = { path = "../persist", version = "0.1.0"}
+bdk_chain = { path = "../chain", version = "0.11.0", features = [ "serde", "miniscript" ] }
 bincode = { version = "1" }
 serde = { version = "1", features = ["derive"] }

--- a/crates/file_store/README.md
+++ b/crates/file_store/README.md
@@ -1,10 +1,10 @@
 # BDK File Store

 This is a simple append-only flat file implementation of
-[`PersistBackend`](bdk_persist::PersistBackend).
+[`Persist`](`bdk_chain::Persist`).

-The main structure is [`Store`](crate::Store), which can be used with [`bdk`]'s
+The main structure is [`Store`](`crate::Store`), which can be used with [`bdk`]'s
 `Wallet` to persist wallet data into a flat file.

 [`bdk`]: https://docs.rs/bdk/latest
-[`bdk_persist`]: https://docs.rs/bdk_persist/latest
+[`bdk_chain`]: https://docs.rs/bdk_chain/latest
--- a/crates/file_store/src/store.rs
+++ b/crates/file_store/src/store.rs
@@ -1,22 +1,21 @@
-use crate::{bincode_options, EntryIter, FileError, IterError};
-use anyhow::anyhow;
-use bdk_chain::Append;
-use bdk_persist::PersistBackend;
-use bincode::Options;
 use std::{
-    fmt::{self, Debug},
+    fmt::Debug,
    fs::{File, OpenOptions},
    io::{self, Read, Seek, Write},
    marker::PhantomData,
    path::Path,
 };

+use bdk_chain::{Append, PersistBackend};
+use bincode::Options;
+
+use crate::{bincode_options, EntryIter, FileError, IterError};
+
 /// Persists an append-only list of changesets (`C`) to a single file.
+///
+/// The changesets are the results of altering a tracker implementation (`T`).
 #[derive(Debug)]
-pub struct Store<C>
-where
-    C: Sync + Send,
-{
+pub struct Store<C> {
    magic_len: usize,
    db_file: File,
    marker: PhantomData<C>,
@@ -24,30 +23,24 @@ where

 impl<C> PersistBackend<C> for Store<C>
 where
-    C: Append
-        + serde::Serialize
-        + serde::de::DeserializeOwned
-        + core::marker::Send
-        + core::marker::Sync,
+    C: Append + serde::Serialize + serde::de::DeserializeOwned,
 {
-    fn write_changes(&mut self, changeset: &C) -> anyhow::Result<()> {
+    type WriteError = std::io::Error;
+
+    type LoadError = IterError;
+
+    fn write_changes(&mut self, changeset: &C) -> Result<(), Self::WriteError> {
        self.append_changeset(changeset)
-            .map_err(|e| anyhow!(e).context("failed to write changes to persistence backend"))
    }

-    fn load_from_persistence(&mut self) -> anyhow::Result<Option<C>> {
-        self.aggregate_changesets()
-            .map_err(|e| anyhow!(e.iter_error).context("error loading from persistence backend"))
+    fn load_from_persistence(&mut self) -> Result<Option<C>, Self::LoadError> {
+        self.aggregate_changesets().map_err(|e| e.iter_error)
    }
 }

 impl<C> Store<C>
 where
-    C: Append
-        + serde::Serialize
-        + serde::de::DeserializeOwned
-        + core::marker::Send
-        + core::marker::Sync,
+    C: Append + serde::Serialize + serde::de::DeserializeOwned,
 {
    /// Create a new [`Store`] file in write-only mode; error if the file exists.
    ///
@@ -71,7 +64,6 @@ where
            .create(true)
            .read(true)
            .write(true)
-            .truncate(true)
            .open(file_path)?;
        f.write_all(magic)?;
        Ok(Self {
@@ -151,7 +143,7 @@ where
    ///
    /// 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
-    /// changesets was unable to read changes of the derivation indices of a keychain.
+    /// changesets it was unable to read changed the derivation indices of the tracker.
    ///
    /// **WARNING**: This method changes the write position of the underlying file. The next
    /// changeset will be written over the erroring entry (or the end of the file if none existed).
@@ -189,7 +181,7 @@ where
        bincode_options()
            .serialize_into(&mut self.db_file, changeset)
            .map_err(|e| match *e {
-                bincode::ErrorKind::Io(error) => error,
+                bincode::ErrorKind::Io(inner) => inner,
                unexpected_err => panic!("unexpected bincode error: {}", unexpected_err),
            })?;

@@ -219,7 +211,7 @@ impl<C> std::fmt::Display for AggregateChangesetsError<C> {
    }
 }

-impl<C: fmt::Debug> std::error::Error for AggregateChangesetsError<C> {}
+impl<C: std::fmt::Debug> std::error::Error for AggregateChangesetsError<C> {}

 #[cfg(test)]
 mod test {
@@ -239,6 +231,9 @@ mod test {

    type TestChangeSet = BTreeSet<String>;

+    #[derive(Debug)]
+    struct TestTracker;
+
    /// Check behavior of [`Store::create_new`] and [`Store::open`].
    #[test]
    fn construct_store() {
--- a/crates/hwi/Cargo.toml
+++ b/crates/hwi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk_hwi"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 homepage = "https://bitcoindevkit.org"
 repository = "https://github.com/bitcoindevkit/bdk"
@@ -10,4 +10,4 @@ readme = "README.md"

 [dependencies]
 bdk = { path = "../bdk" }
-hwi = { version = "0.8.0", features = [ "miniscript"] }
+hwi = { version = "0.7.0", features = [ "miniscript"] }
--- a/crates/hwi/src/lib.rs
+++ b/crates/hwi/src/lib.rs
@@ -6,7 +6,8 @@
 //! # use bdk::bitcoin::Network;
 //! # use bdk::signer::SignerOrdering;
 //! # use bdk_hwi::HWISigner;
-//! # use bdk::{KeychainKind, SignOptions, Wallet};
+//! # use bdk::wallet::AddressIndex::New;
+//! # use bdk::{FeeRate, KeychainKind, SignOptions, Wallet};
 //! # use hwi::HWIClient;
 //! # use std::sync::Arc;
 //! #
--- a/crates/hwi/src/signer.rs
+++ b/crates/hwi/src/signer.rs
@@ -1,6 +1,6 @@
 use bdk::bitcoin::bip32::Fingerprint;
+use bdk::bitcoin::psbt::PartiallySignedTransaction;
 use bdk::bitcoin::secp256k1::{All, Secp256k1};
-use bdk::bitcoin::Psbt;

 use hwi::error::Error;
 use hwi::types::{HWIChain, HWIDevice};
@@ -37,7 +37,7 @@ impl SignerCommon for HWISigner {
 impl TransactionSigner for HWISigner {
    fn sign_transaction(
        &self,
-        psbt: &mut Psbt,
+        psbt: &mut PartiallySignedTransaction,
        _sign_options: &bdk::SignOptions,
        _secp: &Secp256k1<All>,
    ) -> Result<(), SignerError> {
--- a/crates/persist/Cargo.toml
+++ b/crates/persist/Cargo.toml
@@ -1,19 +0,0 @@
-[package]
-name = "bdk_persist"
-homepage = "https://bitcoindevkit.org"
-version = "0.1.0"
-repository = "https://github.com/bitcoindevkit/bdk"
-documentation = "https://docs.rs/bdk_persist"
-description = "Types that define data persistence of a BDK wallet"
-keywords = ["bitcoin", "wallet", "persistence", "database"]
-readme = "README.md"
-license = "MIT OR Apache-2.0"
-authors = ["Bitcoin Dev Kit Developers"]
-edition = "2021"
-rust-version = "1.63"
-
-[dependencies]
-anyhow = { version = "1", default-features = false }
-bdk_chain = { path = "../chain", version = "0.13.0", default-features = false }
-
-
--- a/crates/persist/README.md
+++ b/crates/persist/README.md
@@ -1,3 +0,0 @@
-# BDK Persist
-
-This crate is home to the [`PersistBackend`](crate::PersistBackend) trait which defines the behavior of a database to perform the task of persisting changes made to BDK data structures. The [`Persist`](crate::Persist) type provides a convenient wrapper around a `PersistBackend` that allows staging changes before committing them.
--- a/crates/persist/src/lib.rs
+++ b/crates/persist/src/lib.rs
@@ -1,5 +0,0 @@
-#![doc = include_str!("../README.md")]
-#![no_std]
-#![warn(missing_docs)]
-mod persist;
-pub use persist::*;
--- a/crates/testenv/Cargo.toml
+++ b/crates/testenv/Cargo.toml
@@ -1,24 +0,0 @@
-[package]
-name = "bdk_testenv"
-version = "0.3.0"
-edition = "2021"
-rust-version = "1.63"
-homepage = "https://bitcoindevkit.org"
-repository = "https://github.com/bitcoindevkit/bdk"
-documentation = "https://docs.rs/bdk_testenv"
-description = "Testing framework for BDK chain sources."
-license = "MIT OR Apache-2.0"
-readme = "README.md"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bitcoincore-rpc = { version = "0.18" }
-bdk_chain = { path = "../chain", version = "0.13", default-features = false }
-electrsd = { version= "0.27.1", features = ["bitcoind_25_0", "esplora_a33e97e1", "legacy"] }
-anyhow = { version = "1" }
-
-[features]
-default = ["std"]
-std = ["bdk_chain/std"]
-serde = ["bdk_chain/serde"]
--- a/crates/testenv/README.md
+++ b/crates/testenv/README.md
@@ -1,6 +0,0 @@
-# BDK TestEnv
-
-This crate sets up a regtest environment with a single [`bitcoind`] node
-connected to an [`electrs`] instance. This framework provides the infrastructure
-for testing chain source crates, e.g., [`bdk_chain`], [`bdk_electrum`],
-[`bdk_esplora`], etc.
--- a/crates/testenv/src/lib.rs
+++ b/crates/testenv/src/lib.rs
@@ -1,300 +0,0 @@
-use bdk_chain::{
-    bitcoin::{
-        address::NetworkChecked, block::Header, hash_types::TxMerkleNode, hashes::Hash,
-        secp256k1::rand::random, transaction, Address, Amount, Block, BlockHash, CompactTarget,
-        ScriptBuf, ScriptHash, Transaction, TxIn, TxOut, Txid,
-    },
-    local_chain::CheckPoint,
-    BlockId,
-};
-use bitcoincore_rpc::{
-    bitcoincore_rpc_json::{GetBlockTemplateModes, GetBlockTemplateRules},
-    RpcApi,
-};
-use electrsd::electrum_client::ElectrumApi;
-use std::time::Duration;
-
-/// Struct for running a regtest environment with a single `bitcoind` node with an `electrs`
-/// instance connected to it.
-pub struct TestEnv {
-    pub bitcoind: electrsd::bitcoind::BitcoinD,
-    pub electrsd: electrsd::ElectrsD,
-}
-
-impl TestEnv {
-    /// Construct a new [`TestEnv`] instance with default configurations.
-    pub fn new() -> anyhow::Result<Self> {
-        let bitcoind = match std::env::var_os("BITCOIND_EXE") {
-            Some(bitcoind_path) => electrsd::bitcoind::BitcoinD::new(bitcoind_path),
-            None => {
-                let bitcoind_exe = electrsd::bitcoind::downloaded_exe_path()
-                    .expect(
-                "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature",
-                );
-                electrsd::bitcoind::BitcoinD::with_conf(
-                    bitcoind_exe,
-                    &electrsd::bitcoind::Conf::default(),
-                )
-            }
-        }?;
-
-        let mut electrsd_conf = electrsd::Conf::default();
-        electrsd_conf.http_enabled = true;
-        let electrsd = match std::env::var_os("ELECTRS_EXE") {
-            Some(env_electrs_exe) => {
-                electrsd::ElectrsD::with_conf(env_electrs_exe, &bitcoind, &electrsd_conf)
-            }
-            None => {
-                let electrs_exe = electrsd::downloaded_exe_path()
-                    .expect("electrs version feature must be enabled");
-                electrsd::ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf)
-            }
-        }?;
-
-        Ok(Self { bitcoind, electrsd })
-    }
-
-    /// Exposes the [`ElectrumApi`] calls from the Electrum client.
-    pub fn electrum_client(&self) -> &impl ElectrumApi {
-        &self.electrsd.client
-    }
-
-    /// Exposes the [`RpcApi`] calls from [`bitcoincore_rpc`].
-    pub fn rpc_client(&self) -> &impl RpcApi {
-        &self.bitcoind.client
-    }
-
-    // Reset `electrsd` so that new blocks can be seen.
-    pub fn reset_electrsd(mut self) -> anyhow::Result<Self> {
-        let mut electrsd_conf = electrsd::Conf::default();
-        electrsd_conf.http_enabled = true;
-        let electrsd = match std::env::var_os("ELECTRS_EXE") {
-            Some(env_electrs_exe) => {
-                electrsd::ElectrsD::with_conf(env_electrs_exe, &self.bitcoind, &electrsd_conf)
-            }
-            None => {
-                let electrs_exe = electrsd::downloaded_exe_path()
-                    .expect("electrs version feature must be enabled");
-                electrsd::ElectrsD::with_conf(electrs_exe, &self.bitcoind, &electrsd_conf)
-            }
-        }?;
-        self.electrsd = electrsd;
-        Ok(self)
-    }
-
-    /// Mine a number of blocks of a given size `count`, which may be specified to a given coinbase
-    /// `address`.
-    pub fn mine_blocks(
-        &self,
-        count: usize,
-        address: Option<Address>,
-    ) -> anyhow::Result<Vec<BlockHash>> {
-        let coinbase_address = match address {
-            Some(address) => address,
-            None => self
-                .bitcoind
-                .client
-                .get_new_address(None, None)?
-                .assume_checked(),
-        };
-        let block_hashes = self
-            .bitcoind
-            .client
-            .generate_to_address(count as _, &coinbase_address)?;
-        Ok(block_hashes)
-    }
-
-    /// Mine a block that is guaranteed to be empty even with transactions in the mempool.
-    pub fn mine_empty_block(&self) -> anyhow::Result<(usize, BlockHash)> {
-        let bt = self.bitcoind.client.get_block_template(
-            GetBlockTemplateModes::Template,
-            &[GetBlockTemplateRules::SegWit],
-            &[],
-        )?;
-
-        let txdata = vec![Transaction {
-            version: transaction::Version::ONE,
-            lock_time: bdk_chain::bitcoin::absolute::LockTime::from_height(0)?,
-            input: vec![TxIn {
-                previous_output: bdk_chain::bitcoin::OutPoint::default(),
-                script_sig: ScriptBuf::builder()
-                    .push_int(bt.height as _)
-                    // randomn number so that re-mining creates unique block
-                    .push_int(random())
-                    .into_script(),
-                sequence: bdk_chain::bitcoin::Sequence::default(),
-                witness: bdk_chain::bitcoin::Witness::new(),
-            }],
-            output: vec![TxOut {
-                value: Amount::ZERO,
-                script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()),
-            }],
-        }];
-
-        let bits: [u8; 4] = bt
-            .bits
-            .clone()
-            .try_into()
-            .expect("rpc provided us with invalid bits");
-
-        let mut block = Block {
-            header: Header {
-                version: bdk_chain::bitcoin::block::Version::default(),
-                prev_blockhash: bt.previous_block_hash,
-                merkle_root: TxMerkleNode::all_zeros(),
-                time: Ord::max(bt.min_time, std::time::UNIX_EPOCH.elapsed()?.as_secs()) as u32,
-                bits: CompactTarget::from_consensus(u32::from_be_bytes(bits)),
-                nonce: 0,
-            },
-            txdata,
-        };
-
-        block.header.merkle_root = block.compute_merkle_root().expect("must compute");
-
-        for nonce in 0..=u32::MAX {
-            block.header.nonce = nonce;
-            if block.header.target().is_met_by(block.block_hash()) {
-                break;
-            }
-        }
-
-        self.bitcoind.client.submit_block(&block)?;
-        Ok((bt.height as usize, block.block_hash()))
-    }
-
-    /// This method waits for the Electrum notification indicating that a new block has been mined.
-    pub fn wait_until_electrum_sees_block(&self) -> anyhow::Result<()> {
-        self.electrsd.client.block_headers_subscribe()?;
-        let mut delay = Duration::from_millis(64);
-
-        loop {
-            self.electrsd.trigger()?;
-            self.electrsd.client.ping()?;
-            if self.electrsd.client.block_headers_pop()?.is_some() {
-                return Ok(());
-            }
-
-            if delay.as_millis() < 512 {
-                delay = delay.mul_f32(2.0);
-            }
-            std::thread::sleep(delay);
-        }
-    }
-
-    /// Invalidate a number of blocks of a given size `count`.
-    pub fn invalidate_blocks(&self, count: usize) -> anyhow::Result<()> {
-        let mut hash = self.bitcoind.client.get_best_block_hash()?;
-        for _ in 0..count {
-            let prev_hash = self
-                .bitcoind
-                .client
-                .get_block_info(&hash)?
-                .previousblockhash;
-            self.bitcoind.client.invalidate_block(&hash)?;
-            match prev_hash {
-                Some(prev_hash) => hash = prev_hash,
-                None => break,
-            }
-        }
-        Ok(())
-    }
-
-    /// Reorg a number of blocks of a given size `count`.
-    /// Refer to [`TestEnv::mine_empty_block`] for more information.
-    pub fn reorg(&self, count: usize) -> anyhow::Result<Vec<BlockHash>> {
-        let start_height = self.bitcoind.client.get_block_count()?;
-        self.invalidate_blocks(count)?;
-
-        let res = self.mine_blocks(count, None);
-        assert_eq!(
-            self.bitcoind.client.get_block_count()?,
-            start_height,
-            "reorg should not result in height change"
-        );
-        res
-    }
-
-    /// Reorg with a number of empty blocks of a given size `count`.
-    pub fn reorg_empty_blocks(&self, count: usize) -> anyhow::Result<Vec<(usize, BlockHash)>> {
-        let start_height = self.bitcoind.client.get_block_count()?;
-        self.invalidate_blocks(count)?;
-
-        let res = (0..count)
-            .map(|_| self.mine_empty_block())
-            .collect::<Result<Vec<_>, _>>()?;
-        assert_eq!(
-            self.bitcoind.client.get_block_count()?,
-            start_height,
-            "reorg should not result in height change"
-        );
-        Ok(res)
-    }
-
-    /// Send a tx of a given `amount` to a given `address`.
-    pub fn send(&self, address: &Address<NetworkChecked>, amount: Amount) -> anyhow::Result<Txid> {
-        let txid = self
-            .bitcoind
-            .client
-            .send_to_address(address, amount, None, None, None, None, None, None)?;
-        Ok(txid)
-    }
-
-    /// Create a checkpoint linked list of all the blocks in the chain.
-    pub fn make_checkpoint_tip(&self) -> CheckPoint {
-        CheckPoint::from_block_ids((0_u32..).map_while(|height| {
-            self.bitcoind
-                .client
-                .get_block_hash(height as u64)
-                .ok()
-                .map(|hash| BlockId { height, hash })
-        }))
-        .expect("must craft tip")
-    }
-
-    /// Get the genesis hash of the blockchain.
-    pub fn genesis_hash(&self) -> anyhow::Result<BlockHash> {
-        let hash = self.bitcoind.client.get_block_hash(0)?;
-        Ok(hash)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::TestEnv;
-    use anyhow::Result;
-    use bitcoincore_rpc::RpcApi;
-
-    /// This checks that reorgs initiated by `bitcoind` is detected by our `electrsd` instance.
-    #[test]
-    fn test_reorg_is_detected_in_electrsd() -> Result<()> {
-        let env = TestEnv::new()?;
-
-        // Mine some blocks.
-        env.mine_blocks(101, None)?;
-        env.wait_until_electrum_sees_block()?;
-        let height = env.bitcoind.client.get_block_count()?;
-        let blocks = (0..=height)
-            .map(|i| env.bitcoind.client.get_block_hash(i))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        // Perform reorg on six blocks.
-        env.reorg(6)?;
-        env.wait_until_electrum_sees_block()?;
-        let reorged_height = env.bitcoind.client.get_block_count()?;
-        let reorged_blocks = (0..=height)
-            .map(|i| env.bitcoind.client.get_block_hash(i))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        assert_eq!(height, reorged_height);
-
-        // Block hashes should not be equal on the six reorged blocks.
-        for (i, (block, reorged_block)) in blocks.iter().zip(reorged_blocks.iter()).enumerate() {
-            match i <= height as usize - 6 {
-                true => assert_eq!(block, reorged_block),
-                false => assert_ne!(block, reorged_block),
-            }
-        }
-
-        Ok(())
-    }
-}
--- a/example-crates/example_bitcoind_rpc_polling/src/main.rs
+++ b/example-crates/example_bitcoind_rpc_polling/src/main.rs
@@ -188,7 +188,10 @@ fn main() -> anyhow::Result<()> {
                let mut db = db.lock().unwrap();

                let chain_changeset = chain
-                    .apply_update(emission.checkpoint)
+                    .apply_update(local_chain::Update {
+                        tip: emission.checkpoint,
+                        introduce_older_blocks: false,
+                    })
                    .expect("must always apply as we receive blocks in order from emitter");
                let graph_changeset = graph.apply_block_relevant(&emission.block, height);
                db.stage((chain_changeset, graph_changeset));
@@ -298,8 +301,12 @@ fn main() -> anyhow::Result<()> {
                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,
+                        };
                        let chain_changeset = chain
-                            .apply_update(block_emission.checkpoint)
+                            .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);
--- a/example-crates/example_cli/Cargo.toml
+++ b/example-crates/example_cli/Cargo.toml
@@ -7,7 +7,6 @@ edition = "2021"

 [dependencies]
 bdk_chain = { path = "../../crates/chain", features = ["serde", "miniscript"]}
-bdk_persist = { path = "../../crates/persist" }
 bdk_file_store = { path = "../../crates/file_store" }
 bdk_tmp_plan = { path = "../../nursery/tmp_plan" }
 bdk_coin_select = { path = "../../nursery/coin_select" }
--- a/example-crates/example_cli/src/lib.rs
+++ b/example-crates/example_cli/src/lib.rs
@@ -3,14 +3,12 @@ use anyhow::Context;
 use bdk_coin_select::{coin_select_bnb, CoinSelector, CoinSelectorOpt, WeightedValue};
 use bdk_file_store::Store;
 use serde::{de::DeserializeOwned, Serialize};
-use std::{cmp::Reverse, collections::BTreeMap, path::PathBuf, sync::Mutex, time::Duration};
+use std::{cmp::Reverse, collections::HashMap, path::PathBuf, sync::Mutex, time::Duration};

 use bdk_chain::{
    bitcoin::{
-        absolute, address,
-        secp256k1::Secp256k1,
-        sighash::{Prevouts, SighashCache},
-        transaction, Address, Amount, Network, Sequence, Transaction, TxIn, TxOut,
+        absolute, address, psbt::Prevouts, secp256k1::Secp256k1, sighash::SighashCache, Address,
+        Network, Sequence, Transaction, TxIn, TxOut,
    },
    indexed_tx_graph::{self, IndexedTxGraph},
    keychain::{self, KeychainTxOutIndex},
@@ -19,10 +17,9 @@ use bdk_chain::{
        descriptor::{DescriptorSecretKey, KeyMap},
        Descriptor, DescriptorPublicKey,
    },
-    Anchor, Append, ChainOracle, DescriptorExt, FullTxOut,
+    Anchor, Append, ChainOracle, DescriptorExt, FullTxOut, Persist, PersistBackend,
 };
 pub use bdk_file_store;
-use bdk_persist::{Persist, PersistBackend};
 pub use clap;

 use clap::{Parser, Subcommand};
@@ -32,6 +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>;

 #[derive(Parser)]
 #[clap(author, version, about, long_about = None)]
@@ -199,7 +197,7 @@ pub struct CreateTxChange {
 pub fn create_tx<A: Anchor, O: ChainOracle>(
    graph: &mut KeychainTxGraph<A>,
    chain: &O,
-    keymap: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>,
+    keymap: &HashMap<DescriptorPublicKey, DescriptorSecretKey>,
    cs_algorithm: CoinSelectionAlgo,
    address: Address,
    value: u64,
@@ -237,7 +235,7 @@ where
        .iter()
        .map(|(plan, utxo)| {
            WeightedValue::new(
-                utxo.txout.value.to_sat(),
+                utxo.txout.value,
                plan.expected_weight() as _,
                plan.witness_version().is_some(),
            )
@@ -245,7 +243,7 @@ where
        .collect();

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

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

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

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

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

    let mut transaction = Transaction {
-        version: transaction::Version::TWO,
+        version: 0x02,
        // because the temporary planning module does not support timelocks, we can use the chain
        // tip as the `lock_time` for anti-fee-sniping purposes
        lock_time: absolute::LockTime::from_height(chain.get_chain_tip()?.height)
@@ -440,9 +438,9 @@ pub fn planned_utxos<A: Anchor, O: ChainOracle, K: Clone + bdk_tmp_plan::CanDeri

 pub fn handle_commands<CS: clap::Subcommand, S: clap::Args, A: Anchor, O: ChainOracle, C>(
    graph: &Mutex<KeychainTxGraph<A>>,
-    db: &Mutex<Persist<C>>,
+    db: &Mutex<Database<C>>,
    chain: &Mutex<O>,
-    keymap: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>,
+    keymap: &HashMap<DescriptorPublicKey, DescriptorSecretKey>,
    network: Network,
    broadcast: impl FnOnce(S, &Transaction) -> anyhow::Result<()>,
    cmd: Commands<CS, S>,
@@ -667,7 +665,7 @@ pub struct Init<CS: clap::Subcommand, S: clap::Args, C> {
    /// Keychain-txout index.
    pub index: KeychainTxOutIndex<Keychain>,
    /// Persistence backend.
-    pub db: Mutex<Persist<C>>,
+    pub db: Mutex<Database<C>>,
    /// Initial changeset.
    pub init_changeset: C,
 }
@@ -679,13 +677,7 @@ pub fn init<CS: clap::Subcommand, S: clap::Args, C>(
    db_default_path: &str,
 ) -> anyhow::Result<Init<CS, S, C>>
 where
-    C: Default
-        + Append
-        + Serialize
-        + DeserializeOwned
-        + core::marker::Send
-        + core::marker::Sync
-        + 'static,
+    C: Default + Append + Serialize + DeserializeOwned,
 {
    if std::env::var("BDK_DB_PATH").is_err() {
        std::env::set_var("BDK_DB_PATH", db_default_path);
@@ -721,7 +713,7 @@ where
        args,
        keymap,
        index,
-        db: Mutex::new(Persist::new(db_backend)),
+        db: Mutex::new(Database::new(db_backend)),
        init_changeset,
    })
 }
--- a/example-crates/example_electrum/src/main.rs
+++ b/example-crates/example_electrum/src/main.rs
@@ -210,8 +210,8 @@ fn main() -> anyhow::Result<()> {
            if all_spks {
                let all_spks = graph
                    .index
-                    .revealed_spks(..)
-                    .map(|(k, i, spk)| (k.to_owned(), i, spk.to_owned()))
+                    .revealed_spks()
+                    .map(|(k, i, spk)| (k, i, spk.to_owned()))
                    .collect::<Vec<_>>();
                spks = Box::new(spks.chain(all_spks.into_iter().map(|(k, i, spk)| {
                    eprintln!("scanning {}:{}", k, i);
@@ -299,12 +299,12 @@ fn main() -> anyhow::Result<()> {
        relevant_txids.missing_full_txs(graph.graph())
    };

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

    let db_changeset = {
        let mut chain = chain.lock().unwrap();
--- a/example-crates/example_esplora/src/main.rs
+++ b/example-crates/example_esplora/src/main.rs
@@ -1,15 +1,14 @@
 use std::{
-    collections::BTreeSet,
+    collections::{BTreeMap, BTreeSet},
    io::{self, Write},
    sync::Mutex,
 };

 use bdk_chain::{
-    bitcoin::{constants::genesis_block, Address, Network, Txid},
+    bitcoin::{constants::genesis_block, Address, Network, OutPoint, ScriptBuf, Txid},
    indexed_tx_graph::{self, IndexedTxGraph},
    keychain,
    local_chain::{self, LocalChain},
-    spk_client::{FullScanRequest, SyncRequest},
    Append, ConfirmationTimeHeightAnchor,
 };

@@ -61,7 +60,6 @@ enum EsploraCommands {
        esplora_args: EsploraArgs,
    },
 }
-
 impl EsploraCommands {
    fn esplora_args(&self) -> EsploraArgs {
        match self {
@@ -88,7 +86,7 @@ impl EsploraArgs {
            _ => panic!("unsupported network"),
        });

-        let client = esplora_client::Builder::new(esplora_url).build_blocking();
+        let client = esplora_client::Builder::new(esplora_url).build_blocking()?;
        Ok(client)
    }
 }
@@ -151,66 +149,59 @@ fn main() -> anyhow::Result<()> {
    };

    let client = esplora_cmd.esplora_args().client(args.network)?;
-    // Prepare the `IndexedTxGraph` and `LocalChain` updates based on whether we are scanning or
-    // syncing.
-    //
+    // Prepare the `IndexedTxGraph` update based on whether we are scanning or syncing.
    // Scanning: We are iterating through spks of all keychains and scanning for transactions for
    //   each spk. We start with the lowest derivation index spk and stop scanning after `stop_gap`
    //   number of consecutive spks have no transaction history. A Scan is done in situations of
    //   wallet restoration. It is a special case. Applications should use "sync" style updates
    //   after an initial scan.
-    //
    // Syncing: We only check for specified spks, utxos and txids to update their confirmation
    //   status or fetch missing transactions.
-    let (local_chain_changeset, indexed_tx_graph_changeset) = match &esplora_cmd {
+    let indexed_tx_graph_changeset = match &esplora_cmd {
        EsploraCommands::Scan {
            stop_gap,
            scan_options,
            ..
        } => {
-            let request = {
-                let chain_tip = chain.lock().expect("mutex must not be poisoned").tip();
-                let indexed_graph = &*graph.lock().expect("mutex must not be poisoned");
-                FullScanRequest::from_keychain_txout_index(chain_tip, &indexed_graph.index)
-                    .inspect_spks_for_all_keychains({
-                        let mut once = BTreeSet::<Keychain>::new();
-                        move |keychain, spk_i, _| {
-                            if once.insert(keychain) {
-                                eprint!("\nscanning {}: ", keychain);
-                            }
-                            eprint!("{} ", spk_i);
-                            // Flush early to ensure we print at every iteration.
-                            let _ = io::stderr().flush();
+            let keychain_spks = graph
+                .lock()
+                .expect("mutex must not be poisoned")
+                .index
+                .all_unbounded_spk_iters()
+                .into_iter()
+                // This `map` is purely for logging.
+                .map(|(keychain, iter)| {
+                    let mut first = true;
+                    let spk_iter = iter.inspect(move |(i, _)| {
+                        if first {
+                            eprint!("\nscanning {}: ", keychain);
+                            first = false;
                        }
-                    })
-            };
+                        eprint!("{} ", i);
+                        // Flush early to ensure we print at every iteration.
+                        let _ = io::stderr().flush();
+                    });
+                    (keychain, spk_iter)
+                })
+                .collect::<BTreeMap<_, _>>();

            // The client scans keychain spks for transaction histories, stopping after `stop_gap`
            // is reached. It returns a `TxGraph` update (`graph_update`) and a structure that
            // represents the last active spk derivation indices of keychains
            // (`keychain_indices_update`).
-            let mut update = client
-                .full_scan(request, *stop_gap, scan_options.parallel_requests)
+            let (graph_update, last_active_indices) = client
+                .full_scan(keychain_spks, *stop_gap, scan_options.parallel_requests)
                .context("scanning for transactions")?;

-            // We want to keep track of the latest time a transaction was seen unconfirmed.
-            let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-            let _ = update.graph_update.update_last_seen_unconfirmed(now);
-
            let mut graph = graph.lock().expect("mutex must not be poisoned");
-            let mut chain = chain.lock().expect("mutex must not be poisoned");
            // Because we did a stop gap based scan we are likely to have some updates to our
            // deriviation indices. Usually before a scan you are on a fresh wallet with no
            // addresses derived so we need to derive up to last active addresses the scan found
            // before adding the transactions.
-            (chain.apply_update(update.chain_update)?, {
-                let (_, index_changeset) = graph
-                    .index
-                    .reveal_to_target_multi(&update.last_active_indices);
-                let mut indexed_tx_graph_changeset = graph.apply_update(update.graph_update);
-                indexed_tx_graph_changeset.append(index_changeset.into());
-                indexed_tx_graph_changeset
-            })
+            let (_, index_changeset) = graph.index.reveal_to_target_multi(&last_active_indices);
+            let mut indexed_tx_graph_changeset = graph.apply_update(graph_update);
+            indexed_tx_graph_changeset.append(index_changeset.into());
+            indexed_tx_graph_changeset
        }
        EsploraCommands::Sync {
            mut unused_spks,
@@ -231,28 +222,30 @@ fn main() -> anyhow::Result<()> {
                unused_spks = false;
            }

-            let local_tip = chain.lock().expect("mutex must not be poisoned").tip();
            // Spks, outpoints and txids we want updates on will be accumulated here.
-            let mut request = SyncRequest::from_chain_tip(local_tip.clone());
+            let mut spks: Box<dyn Iterator<Item = ScriptBuf>> = Box::new(core::iter::empty());
+            let mut outpoints: Box<dyn Iterator<Item = OutPoint>> = Box::new(core::iter::empty());
+            let mut txids: Box<dyn Iterator<Item = Txid>> = Box::new(core::iter::empty());

            // Get a short lock on the structures to get spks, utxos, and txs that we are interested
            // in.
            {
                let graph = graph.lock().unwrap();
                let chain = chain.lock().unwrap();
+                let chain_tip = chain.tip().block_id();

                if *all_spks {
                    let all_spks = graph
                        .index
-                        .revealed_spks(..)
-                        .map(|(k, i, spk)| (k.to_owned(), i, spk.to_owned()))
+                        .revealed_spks()
+                        .map(|(k, i, spk)| (k, i, spk.to_owned()))
                        .collect::<Vec<_>>();
-                    request = request.chain_spks(all_spks.into_iter().map(|(k, i, spk)| {
-                        eprint!("scanning {}:{}", k, i);
+                    spks = Box::new(spks.chain(all_spks.into_iter().map(|(k, i, spk)| {
+                        eprintln!("scanning {}:{}", k, i);
                        // Flush early to ensure we print at every iteration.
                        let _ = io::stderr().flush();
                        spk
-                    }));
+                    })));
                }
                if unused_spks {
                    let unused_spks = graph
@@ -260,18 +253,17 @@ fn main() -> anyhow::Result<()> {
                        .unused_spks()
                        .map(|(k, i, spk)| (k, i, spk.to_owned()))
                        .collect::<Vec<_>>();
-                    request =
-                        request.chain_spks(unused_spks.into_iter().map(move |(k, i, spk)| {
-                            eprint!(
-                                "Checking if address {} {}:{} has been used",
-                                Address::from_script(&spk, args.network).unwrap(),
-                                k,
-                                i,
-                            );
-                            // Flush early to ensure we print at every iteration.
-                            let _ = io::stderr().flush();
-                            spk
-                        }));
+                    spks = Box::new(spks.chain(unused_spks.into_iter().map(|(k, i, spk)| {
+                        eprintln!(
+                            "Checking if address {} {}:{} has been used",
+                            Address::from_script(&spk, args.network).unwrap(),
+                            k,
+                            i,
+                        );
+                        // Flush early to ensure we print at every iteration.
+                        let _ = io::stderr().flush();
+                        spk
+                    })));
                }
                if utxos {
                    // We want to search for whether the UTXO is spent, and spent by which
@@ -280,14 +272,14 @@ fn main() -> anyhow::Result<()> {
                    let init_outpoints = graph.index.outpoints().iter().cloned();
                    let utxos = graph
                        .graph()
-                        .filter_chain_unspents(&*chain, local_tip.block_id(), init_outpoints)
+                        .filter_chain_unspents(&*chain, chain_tip, init_outpoints)
                        .map(|(_, utxo)| utxo)
                        .collect::<Vec<_>>();
-                    request = request.chain_outpoints(
+                    outpoints = Box::new(
                        utxos
                            .into_iter()
                            .inspect(|utxo| {
-                                eprint!(
+                                eprintln!(
                                    "Checking if outpoint {} (value: {}) has been spent",
                                    utxo.outpoint, utxo.txout.value
                                );
@@ -303,61 +295,56 @@ fn main() -> anyhow::Result<()> {
                    // `EsploraExt::update_tx_graph_without_keychain`.
                    let unconfirmed_txids = graph
                        .graph()
-                        .list_chain_txs(&*chain, local_tip.block_id())
+                        .list_chain_txs(&*chain, chain_tip)
                        .filter(|canonical_tx| !canonical_tx.chain_position.is_confirmed())
                        .map(|canonical_tx| canonical_tx.tx_node.txid)
                        .collect::<Vec<Txid>>();
-                    request = request.chain_txids(unconfirmed_txids.into_iter().inspect(|txid| {
-                        eprint!("Checking if {} is confirmed yet", txid);
+                    txids = Box::new(unconfirmed_txids.into_iter().inspect(|txid| {
+                        eprintln!("Checking if {} is confirmed yet", txid);
                        // Flush early to ensure we print at every iteration.
                        let _ = io::stderr().flush();
                    }));
                }
            }

-            let total_spks = request.spks.len();
-            let total_txids = request.txids.len();
-            let total_ops = request.outpoints.len();
-            request = request
-                .inspect_spks({
-                    let mut visited = 0;
-                    move |_| {
-                        visited += 1;
-                        eprintln!(" [ {:>6.2}% ]", (visited * 100) as f32 / total_spks as f32)
-                    }
-                })
-                .inspect_txids({
-                    let mut visited = 0;
-                    move |_| {
-                        visited += 1;
-                        eprintln!(" [ {:>6.2}% ]", (visited * 100) as f32 / total_txids as f32)
-                    }
-                })
-                .inspect_outpoints({
-                    let mut visited = 0;
-                    move |_| {
-                        visited += 1;
-                        eprintln!(" [ {:>6.2}% ]", (visited * 100) as f32 / total_ops as f32)
-                    }
-                });
-            let mut update = client.sync(request, scan_options.parallel_requests)?;
+            let graph_update =
+                client.sync(spks, txids, outpoints, scan_options.parallel_requests)?;

-            // Update last seen unconfirmed
-            let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-            let _ = update.graph_update.update_last_seen_unconfirmed(now);
-
-            (
-                chain.lock().unwrap().apply_update(update.chain_update)?,
-                graph.lock().unwrap().apply_update(update.graph_update),
-            )
+            graph.lock().unwrap().apply_update(graph_update)
        }
    };

    println!();

+    // Now that we're done updating the `IndexedTxGraph`, it's time to update the `LocalChain`! We
+    // want the `LocalChain` to have data about all the anchors in the `TxGraph` - for this reason,
+    // we want retrieve the blocks at the heights of the newly added anchors that are missing from
+    // our view of the chain.
+    let (missing_block_heights, tip) = {
+        let chain = &*chain.lock().unwrap();
+        let missing_block_heights = indexed_tx_graph_changeset
+            .graph
+            .missing_heights_from(chain)
+            .collect::<BTreeSet<_>>();
+        let tip = chain.tip();
+        (missing_block_heights, tip)
+    };
+
+    println!("prev tip: {}", tip.height());
+    println!("missing block heights: {:?}", missing_block_heights);
+
+    // Here, we actually fetch the missing blocks and create a `local_chain::Update`.
+    let chain_changeset = {
+        let chain_update = client
+            .update_local_chain(tip, missing_block_heights)
+            .context("scanning for blocks")?;
+        println!("new tip: {}", chain_update.tip.height());
+        chain.lock().unwrap().apply_update(chain_update)?
+    };
+
    // We persist the changes
    let mut db = db.lock().unwrap();
-    db.stage((local_chain_changeset, indexed_tx_graph_changeset));
+    db.stage((chain_changeset, indexed_tx_graph_changeset));
    db.commit()?;
    Ok(())
 }
--- a/example-crates/wallet_electrum/src/main.rs
+++ b/example-crates/wallet_electrum/src/main.rs
@@ -8,8 +8,8 @@ use std::str::FromStr;

 use bdk::bitcoin::Address;
 use bdk::wallet::Update;
+use bdk::SignOptions;
 use bdk::{bitcoin::Network, Wallet};
-use bdk::{KeychainKind, SignOptions};
 use bdk_electrum::{
    electrum_client::{self, ElectrumApi},
    ElectrumExt, ElectrumUpdate,
@@ -29,7 +29,7 @@ fn main() -> Result<(), anyhow::Error> {
        Network::Testnet,
    )?;

-    let address = wallet.next_unused_address(KeychainKind::External)?;
+    let address = wallet.try_get_address(bdk::wallet::AddressIndex::New)?;
    println!("Generated Address: {}", address);

    let balance = wallet.get_balance();
@@ -66,9 +66,7 @@ fn main() -> Result<(), anyhow::Error> {
    println!();

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

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

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

--- a/example-crates/wallet_esplora_async/src/main.rs
+++ b/example-crates/wallet_esplora_async/src/main.rs
@@ -1,8 +1,9 @@
-use std::{collections::BTreeSet, io::Write, str::FromStr};
+use std::{io::Write, str::FromStr};

 use bdk::{
-    bitcoin::{Address, Network, Script},
-    KeychainKind, SignOptions, Wallet,
+    bitcoin::{Address, Network},
+    wallet::{AddressIndex, Update},
+    SignOptions, Wallet,
 };
 use bdk_esplora::{esplora_client, EsploraAsyncExt};
 use bdk_file_store::Store;
@@ -26,7 +27,7 @@ async fn main() -> Result<(), anyhow::Error> {
        Network::Testnet,
    )?;

-    let address = wallet.next_unused_address(KeychainKind::External)?;
+    let address = wallet.try_get_address(AddressIndex::New)?;
    println!("Generated Address: {}", address);

    let balance = wallet.get_balance();
@@ -36,44 +37,32 @@ async fn main() -> Result<(), anyhow::Error> {
    let client =
        esplora_client::Builder::new("https://blockstream.info/testnet/api").build_async()?;

-    fn generate_inspect(kind: KeychainKind) -> impl FnMut(u32, &Script) + Send + Sync + 'static {
-        let mut once = Some(());
-        let mut stdout = std::io::stdout();
-        move |spk_i, _| {
-            match once.take() {
-                Some(_) => print!("\nScanning keychain [{:?}]", kind),
-                None => print!(" {:<3}", spk_i),
-            };
-            stdout.flush().expect("must flush");
-        }
-    }
-    let request = wallet
-        .start_full_scan()
-        .inspect_spks_for_all_keychains({
-            let mut once = BTreeSet::<KeychainKind>::new();
-            move |keychain, spk_i, _| {
-                match once.insert(keychain) {
-                    true => print!("\nScanning keychain [{:?}]", keychain),
-                    false => print!(" {:<3}", spk_i),
-                }
-                std::io::stdout().flush().expect("must flush")
-            }
+    let prev_tip = wallet.latest_checkpoint();
+    let keychain_spks = wallet
+        .all_unbounded_spk_iters()
+        .into_iter()
+        .map(|(k, k_spks)| {
+            let mut once = Some(());
+            let mut stdout = std::io::stdout();
+            let k_spks = k_spks
+                .inspect(move |(spk_i, _)| match once.take() {
+                    Some(_) => print!("\nScanning keychain [{:?}]", k),
+                    None => print!(" {:<3}", spk_i),
+                })
+                .inspect(move |_| stdout.flush().expect("must flush"));
+            (k, k_spks)
        })
-        .inspect_spks_for_keychain(
-            KeychainKind::External,
-            generate_inspect(KeychainKind::External),
-        )
-        .inspect_spks_for_keychain(
-            KeychainKind::Internal,
-            generate_inspect(KeychainKind::Internal),
-        );
-
-    let mut update = client
-        .full_scan(request, STOP_GAP, PARALLEL_REQUESTS)
+        .collect();
+    let (update_graph, last_active_indices) = client
+        .full_scan(keychain_spks, STOP_GAP, PARALLEL_REQUESTS)
        .await?;
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-    let _ = update.graph_update.update_last_seen_unconfirmed(now);
-
+    let missing_heights = update_graph.missing_heights(wallet.local_chain());
+    let chain_update = client.update_local_chain(prev_tip, missing_heights).await?;
+    let update = Update {
+        last_active_indices,
+        graph: update_graph,
+        chain: Some(chain_update),
+    };
    wallet.apply_update(update)?;
    wallet.commit()?;
    println!();
@@ -101,7 +90,7 @@ async fn main() -> Result<(), anyhow::Error> {
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    assert!(finalized);

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

--- a/example-crates/wallet_esplora_blocking/src/main.rs
+++ b/example-crates/wallet_esplora_blocking/src/main.rs
@@ -3,11 +3,12 @@ const SEND_AMOUNT: u64 = 1000;
 const STOP_GAP: usize = 5;
 const PARALLEL_REQUESTS: usize = 1;

-use std::{collections::BTreeSet, io::Write, str::FromStr};
+use std::{io::Write, str::FromStr};

 use bdk::{
    bitcoin::{Address, Network},
-    KeychainKind, SignOptions, Wallet,
+    wallet::{AddressIndex, Update},
+    SignOptions, Wallet,
 };
 use bdk_esplora::{esplora_client, EsploraExt};
 use bdk_file_store::Store;
@@ -25,7 +26,7 @@ fn main() -> Result<(), anyhow::Error> {
        Network::Testnet,
    )?;

-    let address = wallet.next_unused_address(KeychainKind::External)?;
+    let address = wallet.try_get_address(AddressIndex::New)?;
    println!("Generated Address: {}", address);

    let balance = wallet.get_balance();
@@ -33,22 +34,34 @@ fn main() -> Result<(), anyhow::Error> {

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

-    let request = wallet.start_full_scan().inspect_spks_for_all_keychains({
-        let mut once = BTreeSet::<KeychainKind>::new();
-        move |keychain, spk_i, _| {
-            match once.insert(keychain) {
-                true => print!("\nScanning keychain [{:?}]", keychain),
-                false => print!(" {:<3}", spk_i),
-            };
-            std::io::stdout().flush().expect("must flush")
-        }
-    });
+    let prev_tip = wallet.latest_checkpoint();
+    let keychain_spks = wallet
+        .all_unbounded_spk_iters()
+        .into_iter()
+        .map(|(k, k_spks)| {
+            let mut once = Some(());
+            let mut stdout = std::io::stdout();
+            let k_spks = k_spks
+                .inspect(move |(spk_i, _)| match once.take() {
+                    Some(_) => print!("\nScanning keychain [{:?}]", k),
+                    None => print!(" {:<3}", spk_i),
+                })
+                .inspect(move |_| stdout.flush().expect("must flush"));
+            (k, k_spks)
+        })
+        .collect();

-    let mut update = client.full_scan(request, STOP_GAP, PARALLEL_REQUESTS)?;
-    let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
-    let _ = update.graph_update.update_last_seen_unconfirmed(now);
+    let (update_graph, last_active_indices) =
+        client.full_scan(keychain_spks, 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 {
+        last_active_indices,
+        graph: update_graph,
+        chain: Some(chain_update),
+    };

    wallet.apply_update(update)?;
    wallet.commit()?;
@@ -77,7 +90,7 @@ fn main() -> Result<(), anyhow::Error> {
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    assert!(finalized);

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

--- a/nursery/coin_select/src/coin_selector.rs
+++ b/nursery/coin_select/src/coin_selector.rs
@@ -96,7 +96,7 @@ impl CoinSelectorOpt {
    ) -> Self {
        let mut tx = Transaction {
            input: vec![],
-            version: transaction::Version::ONE,
+            version: 1,
            lock_time: absolute::LockTime::ZERO,
            output: txouts.to_vec(),
        };
@@ -112,7 +112,7 @@ impl CoinSelectorOpt {
            target_value: if txouts.is_empty() {
                None
            } else {
-                Some(txouts.iter().map(|txout| txout.value.to_sat()).sum())
+                Some(txouts.iter().map(|txout| txout.value).sum())
            },
            ..Self::from_weights(
                base_weight.to_wu() as u32,
--- a/nursery/coin_select/src/lib.rs
+++ b/nursery/coin_select/src/lib.rs
@@ -12,7 +12,7 @@ use bdk_chain::{
    bitcoin,
    collections::{BTreeSet, HashMap},
 };
-use bitcoin::{absolute, transaction, Transaction, TxOut};
+use bitcoin::{absolute, Transaction, TxOut};
 use core::fmt::{Debug, Display};

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

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

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

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

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

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

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

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