diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index 87cffbcf21..455bc8e76d 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -1,5 +1,5 @@
 additional_cargo_args = ["--all-features"]
-examine_globs = ["units/src/**/*.rs", "primitives/src/**/*.rs"]
+examine_globs = ["consensus_encoding/src/**/*.rs", "units/src/**/*.rs", "primitives/src/**/*.rs"]
 exclude_globs = [
     "units/src/amount/verification.rs" # kani tests
 ]
@@ -9,28 +9,58 @@ exclude_re = [
     "impl fmt::Debug",
     ".*Error",
     "deserialize", # Skip serde mutation tests
+    "serde_details::<impl de::Visitor<'_>", # Skip serde mutation tests
     "Iterator", # Mutating operations in an iterator can result in an infinite loop
-    "match arm", "match guard", # New addition in cargo-mutants 25.0.1 deletes match arms and replaces match guards even in excluded functions
+    "<impl .*Decodable for .*>::decoder", # Mutant replacing Default::default() is equivalent to returning new()
+    "<impl .*Decoder for .*>::read_limit", # Function is for optimization and does not need to be tested.
+
 
     # ----------------------------------Crate-specific exclusions----------------------------------
-    # Units
+    # units
     # src/amount/mod.rs
-    "parse_signed_to_satoshi", # Can't kill all mutants since there is no denomination smaller than Satoshi
-    "fmt_satoshi_in", # Related to formatting/display
-    "dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
+    "units/.* parse_signed_to_satoshi", # Can't kill all mutants since there is no denomination smaller than Satoshi
+    "units/.* fmt_satoshi_in", # Related to formatting/display
+    "units/.* dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
     # src/locktime/relative.rs
-    "Time::to_consensus_u32", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
-    "FeeRate::fee_vb", # Deprecated
-    "FeeRate::fee_wu", # Deprecated
-    "SignedAmount::checked_abs", # Deprecated
+    "units/.* LockTime::to_consensus_u32", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
+    "units/.* FeeRate::fee_vb", # Deprecated
+    "units/.* FeeRate::fee_wu", # Deprecated
+    "units/.* SignedAmount::checked_abs", # Deprecated
+    "units/.* NumberOfBlocks::to_consensus_u32", # Deprecated
+    "units/.* NumberOfBlocks::value", # Deprecated
+    "units/.* NumberOf512Seconds::to_consensus_u32", # Deprecated
+    "units/.* NumberOf512Seconds::value", # Deprecated
+    "units/.* MedianTimePast::to_consensus_u32", # Deprecated
+    "units/.* Height::to_consensus_u32", # Deprecated
+    "units/.* Sequence::to_hex", # Deprecated
+    "units/.* Sequence::from_512_second_intervals", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
 
     # primitives
-    "Sequence::from_512_second_intervals", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
-    "Opcode::classify", # Not possible to kill all mutants without individually checking every opcode classification
-    "Block<Checked>::cached_witness_root", # Skip getters
-    "Block<Checked>::transactions", # Skip getters
-    "Script::to_bytes", # Deprecated
-    "decode_cursor", # Mutating operations in decode_cursor can result in an infinite loop
-    "fmt_debug", # Mutants from formatting/display changes
-    "fmt_debug_pretty", # Mutants from formatting/display changes
+    "primitives/.* Opcode::classify", # Not possible to kill all mutants without individually checking every opcode classification
+    "primitives/.* Block<Checked>::cached_witness_root", # Skip getters
+    "primitives/.* Block<Checked>::transactions", # Skip getters
+    "primitives/.* Script::to_bytes", # Deprecated
+    "primitives/.* decode_cursor", # Mutating operations in decode_cursor can result in an infinite loop
+    "primitives/.* fmt_debug", # Mutants from formatting/display changes
+    "primitives/.* fmt_debug_pretty", # Mutants from formatting/display changes
+    "primitives/.* CompactTarget::to_hex", # Deprecated
+    "primitives/.* Script::to_hex", # Deprecated
+    "primitives/.* Script<T>::to_hex", # Deprecated
+    "primitives/.* ScriptBuf::to_hex", # Deprecated
+    "primitives/.* ScriptBuf<T>::to_hex", # Deprecated
+    "primitives/.* <impl Encoder for .*Encoder<'_>>::current_chunk", # Replacing the return with Some(vec![]) causes an infinite loop.
+    "primitives/.* <impl Encoder for .*Encoder<'_>>::advance", # Replacing the return with true causes an infinite loop.
+    "primitives/.* <impl Decoder for WitnessDecoder>::push_bytes", # Replacing == with != causes an infinite loop
+    "primitives/.* WitnessDecoder::resize_if_needed", # Replacing *= with += still resizes the buffer making the mutant untestable.
+    "primitives/.* replace \\+ with \\* in MerkleNode::calculate_root", # Replacing + with * causes an infinite loop
+    "primitives/.* replace == with != in MerkleNode::calculate_root", # Replacing == with != isn't caught unless alloc is disabled.
+
+    # consensus_encoding - most of these are for mutations in the logic used to determine when to stop encoding or decoding.
+    "consensus_encoding/.* <impl Decoder for ArrayDecoder<N>>::push_bytes", # Mutations cause an infinite loop
+    "consensus_encoding/.* <impl Decoder for .*>::end", # Mutations cause an infinite loop
+    "consensus_encoding/.* encode_to_vec", # Mutations cause an infinite loop
+    "consensus_encoding/.* encode_to_writer", # Mutations cause an infinite loop
+    "consensus_encoding/.* decode_from_slice", # Mutations cause an infinite loop
+    "consensus_encoding/.* decode_from_read", # Mutations cause an infinite loop
+    "consensus_encoding/.* <impl Decoder for .*>::push_bytes", # Mutations cause an infinite loop
 ]
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 453228e1c2..bf17342789 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -6,3 +6,7 @@ updates:
     schedule:
       # Check for updates to GitHub Actions every week
       interval: "weekly"
+    # Defines a cooldown period for dependency updates,
+    # allowing updates to be delayed for a configurable number of days.
+    cooldown:
+      default-days: 60
diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index f93b40cd1c..5bb18672f2 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -28,7 +28,13 @@ Run from rust.yml unless stated otherwise. Unfortunately we are now exceeding th
 14. `ASAN`
 15. `WASM`
 16. `Kani`
-17. `Coveralls` - run by `coveralls.yml`
-18. `release` - run by `release.yml`
-19. `labeler` - run by `manage-pr.yml`
-20. `Shellcheck` - run by `shellcheck.yml`
+17. `API`
+18. `Policy` - enforce repository coding policy.
+19. `Re-exports`
+20. `DiffMutants`
+21. `release` - run by `release.yml`
+22. `labeler` - run by `manage-pr.yml`
+23. `Shellcheck` - run by `shellcheck.yml`
+
+If any change touches the `.github/` directory then the `zizmor`, run by `zizmor.yml`, will be
+triggered for that PR.
diff --git a/.github/workflows/cargo-semver-checks-version b/.github/workflows/cargo-semver-checks-version
index 72a8a6313b..bcce5d06b8 100644
--- a/.github/workflows/cargo-semver-checks-version
+++ b/.github/workflows/cargo-semver-checks-version
@@ -1 +1 @@
-0.41.0
+0.45.0
diff --git a/.github/workflows/coveralls.yml b/.github/workflows/coveralls.yml
deleted file mode 100644
index 688481ef81..0000000000
--- a/.github/workflows/coveralls.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-on:
-  - push
-  - pull_request
-
-name: Code coverage with llvm-cov
-
-jobs:
-  Coveralls:
-    name: Code coverage - stable toolchain
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-    steps:
-      - name: Checkout Crate
-        uses: actions/checkout@v4
-      - name: Checkout Toolchain
-        # https://github.com/dtolnay/rust-toolchain
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - name: Generate code coverage for tests
-        run: cargo llvm-cov --ignore-filename-regex fuzz --all-features --workspace --lcov --output-path lcov.info
-      - name: Upload report to coveralls
-        uses: coverallsapp/github-action@v2        
diff --git a/.github/workflows/cron-daily-fuzz.yml b/.github/workflows/cron-daily-fuzz.yml
index 253be2af24..50658c9f18 100644
--- a/.github/workflows/cron-daily-fuzz.yml
+++ b/.github/workflows/cron-daily-fuzz.yml
@@ -7,40 +7,59 @@ on:
     # - 6am CET
     # - 4pm AEDT
     - cron: '00 05 * * *'
+permissions: {}
 
 jobs:
   fuzz:
     if: ${{ !github.event.act }}
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         # We only get 20 jobs at a time, we probably don't want to go
         # over that limit with fuzzing because of the hour run time.
         fuzz_target: [
-          bitcoin_deserialize_address,
+          bitcoin_arbitrary_block,
+          bitcoin_arbitrary_script,
+          bitcoin_arbitrary_transaction,
+          bitcoin_arbitrary_witness,
           bitcoin_deserialize_block,
           bitcoin_deserialize_prefilled_transaction,
           bitcoin_deserialize_psbt,
           bitcoin_deserialize_script,
           bitcoin_deserialize_transaction,
           bitcoin_deserialize_witness,
-          bitcoin_deser_net_msg,
-          bitcoin_outpoint_string,
+          bitcoin_parse_address,
+          bitcoin_parse_outpoint,
           bitcoin_script_bytes_to_asm_fmt,
+          consensus_encoding_decode_array,
+          consensus_encoding_decode_byte_vec,
+          consensus_encoding_decode_compact_size,
+          consensus_encoding_decode_decoder2,
           hashes_json,
           hashes_ripemd160,
           hashes_sha1,
           hashes_sha256,
-          hashes_sha512_256,
           hashes_sha512,
-          units_deserialize_amount,
+          hashes_sha512_256,
+          p2p_arbitrary_addrv2,
+          p2p_deserialize_addrv2,
+          p2p_deserialize_raw_net_msg,
+          units_arbitrary_weight,
+          units_parse_amount,
+          units_parse_int,
+          units_standard_checks,
         ]
     steps:
       - name: Install test dependencies
         run: sudo apt-get update -y && sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+
         id: cache-fuzz
         with:
           path: |
@@ -48,9 +67,9 @@ jobs:
             fuzz/target
             target
           key: cache-${{ matrix.target }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
         with:
-          toolchain: '1.65.0'
+          toolchain: '1.74.0'
       - name: fuzz
         run: |
           if [[ "${{ matrix.fuzz_target }}" =~ ^bitcoin ]]; then
@@ -59,7 +78,7 @@ jobs:
           echo "Using RUSTFLAGS $RUSTFLAGS"
           cd fuzz && ./fuzz.sh "${{ matrix.fuzz_target }}"
       - run: echo "${{ matrix.fuzz_target }}" >executed_${{ matrix.fuzz_target }}
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: executed_${{ matrix.fuzz_target }}
           path: executed_${{ matrix.fuzz_target }}
@@ -68,9 +87,13 @@ jobs:
     if: ${{ !github.event.act }}
     needs: fuzz
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
       - name: Display structure of downloaded files
         run: ls -R
       - run: find executed_* -type f -exec cat {} + | sort > executed
diff --git a/.github/workflows/cron-daily-kani.yml b/.github/workflows/cron-daily-kani.yml
index 61ef6e3957..18191a5bc3 100644
--- a/.github/workflows/cron-daily-kani.yml
+++ b/.github/workflows/cron-daily-kani.yml
@@ -3,12 +3,17 @@ name: Kani CI
 on:
   schedule:
     - cron: '59 23 * * *'       # midnight every day.
+permissions: {}
 jobs:
   run-kani:
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
       - name: 'Checkout your code.'
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
 
       - name: 'Run Kani on your code.'
-        uses: model-checking/kani-github-action@v1.1
+        uses: model-checking/kani-github-action@f838096619a707b0f6b2118cf435eaccfa33e51f # v1.1
diff --git a/.github/workflows/cron-weekly-cargo-mutants.yml b/.github/workflows/cron-weekly-cargo-mutants.yml
index 74ec346299..1b0a989fd7 100644
--- a/.github/workflows/cron-weekly-cargo-mutants.yml
+++ b/.github/workflows/cron-weekly-cargo-mutants.yml
@@ -3,16 +3,22 @@ on:
   schedule:
     - cron: "0 0 * * 0" # runs weekly on Sunday at 00:00
   workflow_dispatch: # allows manual triggering
+permissions: {}
 jobs:
   cargo-mutants:
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+      issues: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: taiki-e/install-action@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: taiki-e/install-action@81ee1d48d9194cdcab880cbdc7d36e87d39874cb # v2.62.45
         with:
           tool: cargo-mutants
       - run: cargo mutants --in-place --no-shuffle
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         if: always()
         with:
           name: mutants.out
@@ -22,13 +28,15 @@ jobs:
         run: |
           if [ -s mutants.out/missed.txt ]; then
             echo "New missed mutants found"
+            MUTANTS_VERSION=$(cargo mutants --version)
             gh issue create \
             --title "New Mutants Found" \
             --body "$(cat <<EOF
           Displaying up to the first 10 mutants:
-
+          \`\`\`
           $(head -n 10 mutants.out/missed.txt)
-
+          \`\`\`
+          Running cargo mutants version: ${MUTANTS_VERSION}
           For the complete list, please check the [mutants.out artifact](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}).
           EOF
           )"
diff --git a/.github/workflows/cron-weekly-rustfmt.yml b/.github/workflows/cron-weekly-rustfmt.yml
index ba11521049..81e751ba8d 100644
--- a/.github/workflows/cron-weekly-rustfmt.yml
+++ b/.github/workflows/cron-weekly-rustfmt.yml
@@ -3,22 +3,28 @@ on:
   schedule:
     - cron: "0 0 * * 0" # runs weekly on Sunday at 00:00
   workflow_dispatch: # allows manual triggering
+permissions: {}
 jobs:
   format:
     name: Nightly rustfmt
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@55d80eb3c5a4228eec5390a083c092095115c6f1 # nightly
         with:
           components: rustfmt
       - name: Run Nightly rustfmt
         # Run the formatter and manually remove trailing whitespace.
-        run: cargo +nightly fmt && find . -type f -name '*.rs' -exec sed -i 's/ $//' {} \;
+        run: cargo +nightly fmt && git ls-files -- '*.rs' -z | xargs sed -E -i'' -e 's/[[:space:]]+$//'
       - name: Get the current date
         run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_ENV
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
         with:
           author: Fmt Bot <bot@example.com>
           title: Automated nightly rustfmt (${{ env.date }})
@@ -26,3 +32,4 @@ jobs:
            Automated nightly `rustfmt` changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action
           commit-message: ${{ env.date }} automated rustfmt nightly 
           labels: rustfmt
+        
diff --git a/.github/workflows/cron-weekly-update-cargo-semver-checks.yml b/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
index 75f706a1cc..4f32e1d934 100644
--- a/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
+++ b/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
@@ -3,18 +3,24 @@ on:
   schedule:
     - cron: "0 0 * * 6" # runs every Saturday at 00:00
   workflow_dispatch: # allows manual triggering
+permissions: {}
 jobs:
   format:
     name: Update cargo-semver-checks
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: Update semver-checks to use latest crates.io published version
         run: |
           set -x
           # Grab the latest version of cargo semver-checks from crates.io
           # that is not yanked.
-          LATEST_VERSION=$(curl --proto '=https' --tlsv1.3 -sSf https://crates.io/api/v1/crates/cargo-semver-checks/versions | jq -r 'first( .versions[] | select(.yanked == false) ) | .num')
+          LATEST_VERSION=$(curl --proto '=https' --tlsv1.3 -sSf -H "User-Agent: rust-bitcoin-ci" https://crates.io/api/v1/crates/cargo-semver-checks/versions | jq -r 'first( .versions[] | select(.yanked == false) ) | .num')
           # Update the latest version in the reference file.
           echo "${LATEST_VERSION}" > ./.github/workflows/cargo-semver-checks-version
           echo "cargo_semver_checks_version=${LATEST_VERSION}" >> $GITHUB_ENV
@@ -28,7 +34,7 @@ jobs:
           fi
       - name: Create Pull Request
         if: env.changes_made == 'true'
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
         with:
           token: ${{ secrets.APOELSTRA_CREATE_PR_TOKEN }}
           author: Update cargo-semver-checks Bot <bot@example.com>
diff --git a/.github/workflows/cron-weekly-update-nightly.yml b/.github/workflows/cron-weekly-update-nightly.yml
index b31ad20cc0..5363c666fb 100644
--- a/.github/workflows/cron-weekly-update-nightly.yml
+++ b/.github/workflows/cron-weekly-update-nightly.yml
@@ -3,13 +3,20 @@ on:
   schedule:
     - cron: "5 0 * * 6" # Saturday at 00:05
   workflow_dispatch: # allows manual triggering
+permissions: {}
 jobs:
   format:
     name: Update nightly rustc
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      id-token: write
+      pull-requests: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@55d80eb3c5a4228eec5390a083c092095115c6f1 # nightly
       - name: Update rust.yml to use latest nightly
         run: |
           set -x
@@ -29,7 +36,7 @@ jobs:
           fi
       - name: Create Pull Request
         if: env.changes_made == 'true'
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
         with:
           token: ${{ secrets.APOELSTRA_CREATE_PR_TOKEN }}
           author: Update Nightly Rustc Bot <bot@example.com>
diff --git a/.github/workflows/cron-weekly-update-stable.yml b/.github/workflows/cron-weekly-update-stable.yml
index 456ccd9ae4..4c2c3f14ca 100644
--- a/.github/workflows/cron-weekly-update-stable.yml
+++ b/.github/workflows/cron-weekly-update-stable.yml
@@ -3,13 +3,19 @@ on:
   schedule:
     - cron: "0 0 * * 5" # runs every Friday at 00:00 (generally rust releases on Thursday)
   workflow_dispatch: # allows manual triggering
+permissions: {}
 jobs:
   format:
     name: Update stable rustc
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: Update semver-checks.yml to use latest stable
         run: |
           set -x
@@ -28,7 +34,7 @@ jobs:
           fi
       - name: Create Pull Request
         if: env.changes_made == 'true'
-        uses: peter-evans/create-pull-request@v7
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
         with:
           token: ${{ secrets.APOELSTRA_CREATE_PR_TOKEN }}
           author: Update Stable Rustc Bot <bot@example.com>
diff --git a/.github/workflows/cron-zizmor.yml b/.github/workflows/cron-zizmor.yml
new file mode 100644
index 0000000000..8d70f3fe3b
--- /dev/null
+++ b/.github/workflows/cron-zizmor.yml
@@ -0,0 +1,33 @@
+name: Automated GitHub Actions Security Analysis with zizmor 🌈
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # Run every day at midnight
+
+permissions: {}
+
+jobs:
+  zizmor:
+    name: zizmor latest via PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v4
+        with:
+          persist-credentials: false
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v5
+
+      - name: Run zizmor 🌈
+        run: uvx zizmor --format sarif . > results.sarif
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload SARIF file
+        uses: github/codeql-action/upload-sarif@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3
+        with:
+          sarif_file: results.sarif
+          category: zizmor
diff --git a/.github/workflows/gh-release.yml b/.github/workflows/gh-release.yml
index 86014a98cf..c8e3301004 100644
--- a/.github/workflows/gh-release.yml
+++ b/.github/workflows/gh-release.yml
@@ -5,11 +5,17 @@ on:
     tags:
     - '*'
 
+permissions: {}
+
 jobs:
   build:
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
     steps:
-    - uses: actions/checkout@v4
-    - uses: ncipollo/release-action@v1
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      with:
+        persist-credentials: false
+    - uses: ncipollo/release-action@b7eabc95ff50cbeeedec83973935c8f306dfcd0b # v1.20.0
       with:
         generateReleaseNotes: true
diff --git a/.github/workflows/manage-pr.yml b/.github/workflows/manage-pr.yml
index 3e92b33f94..b22bd3545e 100644
--- a/.github/workflows/manage-pr.yml
+++ b/.github/workflows/manage-pr.yml
@@ -1,6 +1,7 @@
 name: Manage PR
 on:
-  - pull_request_target
+  - pull_request_target # zizmor: ignore[dangerous-triggers]
+permissions: {}
 
 jobs:
   labeler:
@@ -10,18 +11,20 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout master
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: master
+          persist-credentials: false
       - name: Checkout merge commit
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           path: merge
           ref: "refs/pull/${{ github.event.number }}/merge"
+          persist-credentials: false
       - name: Generate label config
         run: cd master && SCAN_DIR=../merge ./contrib/gen_label_config.sh
       - name: Update labels
-        uses: actions/labeler@v5
+        uses: actions/labeler@634933edcd8ababfe52f92936142cc22ac488b1b # v6.0.1
         with:
           configuration-path: master/.github/labeler.yml
           sync-labels: true
diff --git a/.github/workflows/miri.yml b/.github/workflows/miri.yml
index ed9f05a702..718bd0de7f 100644
--- a/.github/workflows/miri.yml
+++ b/.github/workflows/miri.yml
@@ -8,20 +8,26 @@ on:   # yamllint disable-line rule:truthy
 
 name: Miri
 
+permissions: {}
+
 jobs:
   Miri:
     name: Miri
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Read nightly version"
         id: read_toolchain
         run: echo "nightly_version=$(cat nightly-version)" >> $GITHUB_OUTPUT
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ steps.read_toolchain.outputs.nightly_version }}
           components: miri
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 1241ecf9ba..4f8d40c510 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -8,15 +8,20 @@ on:
   pull_request:
 
 name: Release
+permissions: {}
 
 jobs:
   release:
     name: Release - dry-run
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
     steps:
       - name: Checkout Crate
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: Checkout Toolchain
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: run cargo
         run: contrib/release.sh
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index ea83c99cbc..b6a9f5e6b7 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -8,36 +8,51 @@ on:   # yamllint disable-line rule:truthy
 
 name: Continuous integration
 
+permissions: {}
+
 jobs:
   Prepare:
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     outputs:
       nightly_version: ${{ steps.read_toolchain.outputs.nightly_version }}
+      maintainer_tools_version: ${{ steps.read_toolchain.outputs.maintainer_tools_version }}
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
-      - name: "Read nightly version"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: "Read workspace versions"
         id: read_toolchain
-        run: echo "nightly_version=$(cat nightly-version)" >> $GITHUB_OUTPUT
+        run: |
+          echo "nightly_version=$(cat nightly-version)" >> $GITHUB_OUTPUT
+          echo "maintainer_tools_version=$(cat maintainer-tools-version)" >> $GITHUB_OUTPUT
 
   Stable:                       # 2 jobs, one per manifest.
     name: Test - stable toolchain
+    needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [minimal, recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Set dependencies"
         run: cp Cargo-${{ matrix.dep }}.lock Cargo.lock
       - name: "Run test script"
@@ -47,21 +62,26 @@ jobs:
     name: Test - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [minimal, recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Set dependencies"
@@ -71,24 +91,36 @@ jobs:
 
   MSRV:                         # 2 jobs, one per manifest.
     name: Test - MSRV toolchain
+    needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [minimal, recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
+      - name: "Free disk space"
+        uses: endersonmenezes/free-disk-space@6c4664f43348c8c7011b53488d5ca65e9fc5cd1a # v3.0.0
+        with:
+          remove_android: true
+          remove_dotnet: true
+          remove_haskell: true
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
         with:
-          toolchain: "1.63.0"
+          toolchain: "1.74.0"
       - name: "Set dependencies"
         run: cp Cargo-${{ matrix.dep }}.lock Cargo.lock
       - name: "Run test script"
@@ -98,21 +130,26 @@ jobs:
     name: Lint - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Install clippy"
@@ -124,22 +161,28 @@ jobs:
 
   Docs:
     name: Docs - stable toolchain
+    needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Set dependencies"
         run: cp Cargo-${{ matrix.dep }}.lock Cargo.lock
       - name: "Run test script"
@@ -149,21 +192,26 @@ jobs:
     name: Docs - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Set dependencies"
@@ -175,21 +223,26 @@ jobs:
     name: Bench - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Checkout maintainer tools"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
+          ref: ${{ needs.Prepare.outputs.maintainer_tools_version }}
           path: maintainer-tools
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Set dependencies"
@@ -200,11 +253,15 @@ jobs:
   Arch32bit:
     name: Test 32-bit version
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Add architecture i386"
         run: sudo dpkg --add-architecture i386
       - name: "Install i686 gcc"
@@ -218,11 +275,15 @@ jobs:
     name: Cross test - stable toolchain
     if: ${{ !github.event.act }}
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Install target"
         run: rustup target add s390x-unknown-linux-gnu
       - name: "Install cross"
@@ -234,16 +295,20 @@ jobs:
     name: Embedded - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     env:
       RUSTFLAGS: "-C link-arg=-Tlink.x"
       CARGO_TARGET_THUMBV7M_NONE_EABI_RUNNER: "qemu-system-arm -cpu cortex-m3 -machine mps2-an385 -nographic -semihosting-config enable=on,target=native -kernel"
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Set up QEMU"
         run: sudo apt update && sudo apt install -y qemu-system-arm gcc-arm-none-eabi
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
           targets: thumbv7m-none-eabi
@@ -262,15 +327,19 @@ jobs:
     name: ASAN - nightly toolchain
     needs: Prepare
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
         dep: [recent]
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
         with:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Install rust-src"
@@ -283,24 +352,114 @@ jobs:
   WASM:                         # hashes crate only.
     name: WASM - stable toolchain
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       # Note we do not use the recent lock file for wasm testing.
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Run wasm script"
         run: cd hashes && ./contrib/wasm.sh
 
   Kani:
     name: Kani codegen - stable toolchain
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Build Kani proofs"
-        uses: model-checking/kani-github-action@v1.1
+        uses: model-checking/kani-github-action@f838096619a707b0f6b2118cf435eaccfa33e51f # v1.1
         with:
           args: "--only-codegen"
+
+  API:
+    needs: Prepare
+    name: API - nightly toolchain
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        dep: [recent]
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: "Select toolchain"
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
+        with:
+          toolchain: ${{ needs.Prepare.outputs.nightly_version }}
+      - name: "Install cargo-public-api"
+        run: cargo install --locked cargo-public-api --version 0.50.1
+      - name: "Set dependencies"
+        run: cp Cargo-${{ matrix.dep }}.lock Cargo.lock
+      - name: "Run API checker script"
+        run: ./contrib/check-for-api-changes.sh
+
+  Policy:
+    name: Enforce repo policy - stable toolchain
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: "Select toolchain"
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
+      - name: "Run policy script"
+        run: ./contrib/check-for-policy-violations.sh
+
+  Re-exports:
+    name: Check re-exports - stable toolchain
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: "Select toolchain"
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
+      - name: "Run primitives API checker script"
+        run: |
+          contrib/generate-primitives-re-export-test.sh && (cd ./primitives && cargo test --all-features)
+          contrib/generate-bitcoin-re-export-test.sh && (cd ./bitcoin && cargo test --all-features)
+
+  DiffMutants: 
+    name: Check cargo mutants in diff - stable toolchain
+    runs-on: ubuntu-24.04
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+          fetch-depth: 0 # required for full diff context
+      - name: "Select toolchain"
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
+      - name: "Fetch base branch for diff"
+        run: git fetch origin master
+      - name: "Retrieve relative diff"
+        run: git diff origin/master.. | tee git.diff
+      - uses: taiki-e/install-action@81ee1d48d9194cdcab880cbdc7d36e87d39874cb # v2.62.45
+        with:
+          tool: cargo-mutants
+      - run: cargo mutants --no-shuffle --in-diff git.diff
diff --git a/.github/workflows/semver-checks-pr-label.yml b/.github/workflows/semver-checks-pr-label.yml
index c7f9b1c66c..f525ec6d0e 100644
--- a/.github/workflows/semver-checks-pr-label.yml
+++ b/.github/workflows/semver-checks-pr-label.yml
@@ -1,22 +1,25 @@
 on:   # yamllint disable-line rule:truthy
-  workflow_run:
+  workflow_run:  # zizmor: ignore[dangerous-triggers]
     workflows: [Check semver breaks]
     types: [completed]
 
 name: Check semver breaks - Label and Comment PR
 
+permissions: {}
+
 jobs:
   Download:
     name: Download, Unzip and Add Labels/Comments
     runs-on: ubuntu-24.04
     permissions:
+      actions: read
       contents: read
       pull-requests: write
     # only run if CI passes on the "Check semver breaks" workflow
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
     steps:
       - name: "Download artifact"
-        uses: actions/github-script@v7
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             // get all artifacts from the workflow run
@@ -52,7 +55,7 @@ jobs:
         if: ${{ hashFiles('semver-break.zip') != '' }}
         run: unzip -n semver-break.zip
       - name: "Comment and add label on PR - Semver break"
-        uses: actions/github-script@v7
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         if: ${{ hashFiles('semver-break') != '' }}
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/semver-checks.yml b/.github/workflows/semver-checks.yml
index 32d01b6b28..2352b9ef40 100644
--- a/.github/workflows/semver-checks.yml
+++ b/.github/workflows/semver-checks.yml
@@ -2,6 +2,7 @@ on:   # yamllint disable-line rule:truthy
   pull_request:
 
 name: Check semver breaks
+permissions: {}
 
 jobs:
   PR:
@@ -9,18 +10,22 @@ jobs:
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
+    permissions:
+      contents: read
+      pull-requests: write
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           fetch-depth: 0 # we need full history for cargo semver-checks
+          persist-credentials: false
       - name: "Install Rustup"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Select stable-version"
         run: |
           rustup default $(cat ./.github/workflows/stable-version)
       - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@main
+        uses: cargo-bins/cargo-binstall@b3f755e95653da9a2d25b99154edfdbd5b356d0a # v1.15.10
       - name: "Binstall pinned cargo-semver-checks"
         run: cargo binstall cargo-semver-checks@$(cat ./.github/workflows/cargo-semver-checks-version) --no-confirm
       - name: "Run semver checker script"
@@ -38,7 +43,7 @@ jobs:
           echo "$PR_NUMBER" > ./semver-break
       - name: "Save breaking state"
         if: ${{ hashFiles('semver-break') != '' }}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: semver-break
           path: semver-break
@@ -48,16 +53,21 @@ jobs:
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
+    permissions:
+      contents: read
+      pull-requests: write
     steps:
       - name: "Checkout repo"
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
       - name: "Install Rustup"
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
       - name: "Select stable-version"
         run: |
           rustup default $(cat ./.github/workflows/stable-version)
       - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@main
+        uses: cargo-bins/cargo-binstall@b3f755e95653da9a2d25b99154edfdbd5b356d0a # v1.15.10
       - name: "Binstall pinned cargo-semver-checks"
         run: cargo binstall cargo-semver-checks@$(cat ./.github/workflows/cargo-semver-checks-version) --no-confirm
       - name: "Run semver checker script"
diff --git a/.github/workflows/shellcheck.yml b/.github/workflows/shellcheck.yml
index dea02c3a04..84a84841c3 100644
--- a/.github/workflows/shellcheck.yml
+++ b/.github/workflows/shellcheck.yml
@@ -3,13 +3,18 @@ on:
   pull_request:
     branches:
       - master
+permissions: {}
 jobs:
   shellcheck:
     name: Shellcheck
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      with:
+        persist-credentials: false
     - name: Run ShellCheck
-      uses: ludeeus/action-shellcheck@2.0.0
+      uses: ludeeus/action-shellcheck@00cae500b08a931fb5698e11e79bfbd38e612a38 # 2.0.0
       env:
         SHELLCHECK_OPTS: -x # allow outside sources
diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index f634271672..7f229af964 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.87.0
+1.92.0
diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml
new file mode 100644
index 0000000000..0aba6efa03
--- /dev/null
+++ b/.github/workflows/zizmor.yml
@@ -0,0 +1,25 @@
+name: GitHub Actions Security Analysis with zizmor 🌈
+
+on:
+  pull_request:
+    branches: ["**"]
+    paths:
+      - '.github/**'
+
+permissions: {}
+
+jobs:
+  zizmor:
+    name: zizmor latest via PyPI
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v4
+        with:
+          persist-credentials: false
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@85856786d1ce8acfbcc2f13a5f3fbd6b938f9f41 # v5
+
+      - name: Run zizmor 🌈
+        run: uvx zizmor .
diff --git a/.gitignore b/.gitignore
index 48c9cedca4..ab54b690e9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,6 @@ mutants.out*
 # Fuzz artifacts
 hfuzz_target
 hfuzz_workspace
+
+# Local tooling
+.maintainer-tools
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..5e74344fb5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,10 @@
+# Note for Automated Agents
+
+## Commit attribution
+
+If you generate code for this repository, append a commit trailer:
+
+Format:
+```
+Assisted-by: <AI model> <version>
+```
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..eef4bd20cf
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9787a84c4f..c71b450964 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,10 +13,17 @@ changes to this document in a pull request.
 - [General](#general)
 - [Communication channels](#communication-channels)
 - [Asking questions](#asking-questions)
+- [Getting Started](#getting-started)
+  * [Installing Rust](#installing-rust)
+  * [Building](#building)
+- [Development Tools](#development-tools)
+  * [Just](#just)
+  * [Githooks](#githooks)
+  * [Building the docs](#building-the-docs)
 - [Contribution workflow](#contribution-workflow)
   * [Preparing PRs](#preparing-prs)
   * [Peer review](#peer-review)
-  * [CI and Merging](#merging)
+  * [CI and Merging](#ci-and-merging)
   * [Repository maintainers](#repository-maintainers)
 - [Coding conventions](#coding-conventions)
   * [Naming conventions](#naming-conventions)
@@ -25,6 +32,10 @@ changes to this document in a pull request.
   * [Policy](#policy)
 - [Security](#security)
 - [Testing](#testing)
+  * [Unit/Integration tests](#unitintegration-tests)
+  * [Benchmarks](#benchmarks)
+  * [Mutation tests](#mutation-tests)
+  * [Code verification](#code-verification)
 - [Going further](#going-further)
 
 
@@ -42,6 +53,7 @@ money. That being said, we deeply welcome people contributing for the first time
 to an open source project or pick up Rust while contributing. Don't be shy,
 you'll learn.
 
+For a more in depth discussion of our coding policy see [policy.md](./docs/policy.md)
 
 ## Communication channels
 
@@ -67,13 +79,65 @@ We have a dedicated developer channel on IRC, #bitcoin-rust@libera.chat where
 you may get helpful advice if you have questions.
 
 
+## Getting Started
+
+### Installing Rust
+
+Rust can be installed using your package manager of choice or [rustup.rs](https://rustup.rs). The
+former way is considered more secure since it typically doesn't involve trust in the CA system. But
+you should be aware that the version of Rust shipped by your distribution might be out of date.
+Generally this isn't a problem for `rust-bitcoin` since we support much older versions than the
+current stable one (see MSRV section in [README.md](./README.md)).
+
+### Building
+
+The library can be built and tested using [`cargo`](https://github.com/rust-lang/cargo/):
+
+```
+git clone git@github.com:rust-bitcoin/rust-bitcoin.git
+cd rust-bitcoin
+cargo build
+```
+
+You can run tests with:
+
+```
+cargo test
+```
+
+Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more
+detailed instructions.
+
+
+## Development Tools
+
+### Just
+
+We support [`just`](https://just.systems/man/en/) for running dev workflow commands. Run `just` from
+your shell to see a list of available sub-commands.
+
+### Githooks
+
+To assist devs in catching errors _before_ running CI we provide some githooks. Copy the hooks in `githooks/`
+to your githooks folder or run `just githooks-install` to copy them all.
+
+### Building the docs
+
+We build docs with the nightly toolchain, you may wish to use the following shell alias to check
+your documentation changes build correctly.
+
+```
+alias build-docs='RUSTDOCFLAGS="--cfg docsrs" cargo +nightly rustdoc --features="$FEATURES" -- -D rustdoc::broken-intra-doc-links'
+```
+
+
 ## Contribution workflow
 
 The codebase is maintained using the "contributor workflow" where everyone
 without exception contributes patch proposals using "pull requests". This
 facilitates social contribution, easy testing and peer review.
 
-To contribute a patch, the workflow is a as follows:
+To contribute a patch, the workflow is as follows:
 
 1. Fork Repository
 2. Create topic branch
@@ -217,6 +281,10 @@ Use of `unsafe` code is prohibited unless there is a unanimous decision among
 library maintainers on the exclusion from this rule. In such cases there is a
 requirement to test unsafe code with sanitizers including Miri.
 
+### Policy
+
+For broader project policy and guidelines, see [policy.md](./docs/policy.md).
+
 ### API changes
 
 All PRs that change the public API of `rust-bitcoin` will be checked on CI for
@@ -225,294 +293,66 @@ way that is not backwards compatible, the PR will be flagged as a breaking chang
 Please check the [`semver-checks` workflow](.github/workflows/semver-checks.yml).
 Under the hood we use [`cargo-semver-checks`](https://github.com/obi1kenobi/cargo-semver-checks).
 
+## Security
 
-### Policy
-
-We have various `rust-bitcoin` specific coding styles and conventions that are
-grouped here loosely under the term 'policy'. These are things we try to adhere
-to but that you should not need to worry too much about if you are a new
-contributor. Think of this as a place to collect group knowledge that exists in
-the various PRs over the last few years.
-
-#### Import statements
-
-We use the following style for import statements, see
-(https://github.com/rust-bitcoin/rust-bitcoin/discussions/2088) for the discussion that led to this.
-
-```rust
-// Modules first, as they are part of the project's structure.
-pub mod aa_this;
-mod bb_private;
-pub mod cc_that;
-
-// Private imports, rustfmt will sort and merge them correctly.
-use crate::aa_this::{This, That};
-use crate::bb_that;
-
-// Public re-exports.
-#[rustfmt::skip] // Keeps public re-exports separate, because of this we have to sort manually.
-pub use {
-    crate::aa_aa_this,
-    crate::bb_bb::That,
-}
-
-// Avoid wildcard imports, except for 3 rules:
-
-// Rule 1 - test modules.
-#[cfg(test)]
-mod tests {
-    use super::*; // OK
-}
-
-// Rule 2 - enum variants.
-use LockTime::*; // OK
-
-// Rule 3 - opcodes.
-use opcodes::all::*; // OK
-
-// Finally here is an example where we don't allow wildcard imports:
-use crate::prelude::*; // *NOT* OK
-use crate::prelude::{DisplayHex, String, Vec} // OK
-```
-
-#### Return `Self`
-
-Use `Self` as the return type instead of naming the type. When constructing the return value use
-`Self` or the type name, whichever you prefer.
-
-```rust
-/// A counter that is always smaller than 100.
-pub struct Counter(u32);
-
-impl Counter {
-    /// Constructs a new `Counter`.
-    pub fn new() -> Self { Self(0) }
-
-    /// Returns a counter if it is possible to create one from x.
-    pub fn maybe(x: u32) -> Option<Self> {
-        match x {
-            x if x >= 100 => None,
-            c => Some(Counter(c)),
-        }
-    }
-}
-
-impl TryFrom<u32> for Counter {
-    type Error = TooBigError;
-
-    fn try_from(x: u32) -> Result<Self, Self::Error> {
-        if x >= 100 {
-            return Err(TooBigError);
-        }
-        Ok(Counter(x))
-    }
-}
-```
-
-When constructing the return value for error enums use `Self`.
-
-```rust
-impl From<foo::Error> for LongDescriptiveError {
-    fn from(e: foo::Error) -> Self { Self::Foo(e) }
-}
-```
-
-
-#### Errors
-
-Return as much context as possible with errors e.g., if an error was encountered parsing a string
-include the string in the returned error type. If a function consumes costly-to-compute input
-(allocations are also considered costly) it should return the input back in the error type.
-
-More specifically an error should
-
-- be `non_exhaustive` unless we _really_ never want to change it.
-- have private fields unless we are very confident they won't change.
-- derive `Debug, Clone, PartialEq, Eq` (and `Copy` iff not `non_exhaustive`).
-- implement Display using `write_err!()` macro if a variant contains an inner error source.
-- have `Error` suffix on error types (structs and enums).
-- not have `Error` suffix on enum variants.
-- call `internals::impl_from_infallible!`.
-- implement `std::error::Error` if they are public (feature gated on "std").
-- have messages in lower case, except for proper nouns and variable names.
-
-```rust
-/// Documentation for the `Error` type.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]  // Add liberally; if the error type may ever have new variants added.
-pub enum Error {
-    /// Documentation for variant A.
-    A,
-    /// Documentation for variant B.
-    B,
-}
-
-internals::impl_from_infallible!(Error);
-
-```
-
-All errors that live in an `error` module (eg, `foo/error.rs`) and appear in a public function in
-`foo` module should be available from `foo` i.e., should be re-exported from `foo/mod.rs`.
-
-##### `expect` messages
-
-With respect to `expect` messages, they should follow the
-[Rust standard library guidelines](https://doc.rust-lang.org/std/option/enum.Option.html#recommended-message-style).
-More specifically, `expect` messages should be used to describe the reason
-you expect the operation to succeed.
-For example, this `expect` message clearly states why the operation should succeed:
-
-```rust
-/// Serializes the public key to bytes.
-pub fn to_bytes(self) -> Vec<u8> {
-    let mut buf = Vec::new();
-    self.write_into(&mut buf).expect("vecs don't error");
-    buf
-}
-```
-
-Also note that `expect` messages, as with all error messages, should be lower
-case, except for proper nouns and variable names.
-
-<details>
-<summary>The details on why we chose this style</summary>
-
-According to the [Rust standard library](https://doc.rust-lang.org/std/error/index.html#common-message-styles),
-there are two common styles for how to write `expect` messages:
-
-- using the message to present information to users encountering a panic
-  ("expect as error message"); and
-- using the message to present information to developers debugging the panic
-  ("expect as precondition").
-
-We opted to use the "expect as precondition" since it clearly states why the
-operation should succeed.
-This may be better for communicating with developers, since they are the target
-audience for the error message and `rust-bitcoin`.
-
-If you want to know more about the decision error messages and expect messages,
-please check:
-
-- https://github.com/rust-bitcoin/rust-bitcoin/issues/2913
-- https://github.com/rust-bitcoin/rust-bitcoin/issues/3053
-- https://github.com/rust-bitcoin/rust-bitcoin/pull/3019
-</details>
-
-#### Rustdocs
-
-Be liberal with references to BIPs or other documentation; the aim is that devs can learn about
-Bitcoin by hacking on this codebase as opposed to having to learn about Bitcoin first and then start
-hacking on this codebase. Consider the following format, not all sections will be required for all types.
-
-
-```rust
-/// The Bitcoin foobar.
-///
-/// Contains all the data used when passing a foobar around the Bitcoin network.
-///
-/// <details>
-/// <summary>FooBar Original Design</summary>
-///
-/// The foobar was introduced in Bitcoin x.y.z to increase the amount of foo in bar.
-///
-/// </details>
-///
-/// ### Relevant BIPs
-///
-/// * [BIP X - FooBar in Bitcoin](https://github.com/bitcoin/bips/blob/master/bip-0000.mediawiki)
-pub struct FooBar {
-    /// The version in use.
-    pub version: Version
-}
-```
-
-Do use rustdoc subheadings. Do put an empty newline below each heading e.g.,
-
-```rust
-impl FooBar {
-    /// Constructs a `FooBar` from a [`Baz`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `Baz` is not ...
-    ///
-    /// # Panics
-    ///
-    /// If the `Baz`, converted to a `usize`, is out of bounds.
-    pub fn from_baz(baz: Baz) -> Result<Self, Error> {
-        ...
-    }
-}
-```
-
-Add Panics section if any input to the function can trigger a panic.
-
-Generally we prefer to have non-panicking APIs but it is impractical in some cases. If you're not
-sure, feel free to ask. If we determine panicking is more practical it must be documented. Internal
-panics that could theoretically occur because of bugs in our code must not be documented.
-
-Example code within the rustdocs should compile and lint with `just lint` without any errors or
-warnings.
-
-#### Derives
-
-We try to use standard set of derives if it makes sense:
+Security is the primary focus for this library; disclosure of security
+vulnerabilities helps prevent user loss of funds. If you believe a vulnerability
+may affect other implementations, please disclose this information according to
+the [security guidelines](./SECURITY.md), work on which is currently in progress.
+Before it is completed, feel free to send disclosure to Andrew Poelstra,
+apoelstra@wpsoftware.net, encrypted with his public key from
+<https://www.wpsoftware.net/andrew/andrew.gpg>.
 
-```
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-enum Foo {
-    Bar,
-    Baz,
-}
-```
 
-For types that do should not form a total or partial order, or that technically do but it does not
-make sense to compare them, we use the `Ordered` trait from the
-[`ordered`](https://crates.io/crates/ordered) crate. See `absolute::LockTime` for an example.
+## Testing
 
-For error types you likely want to use `#[derive(Debug, Clone, PartialEq, Eq)]`.
+Related to the security aspect, rust bitcoin developers take testing very
+seriously. Due to the modular nature of the project, writing new test cases is
+easy and good test coverage of the codebase is an important goal. Refactoring
+the project to enable fine-grained unit testing is also an ongoing effort.
 
-See [Errors](#errors) section.
+Unit and integration tests are available for those interested, along with benchmarks. For project
+developers, especially new contributors looking for something to work on, we do:
 
+- Fuzz testing with [`Honggfuzz`](https://github.com/rust-fuzz/honggfuzz-rs)
+- Mutation testing with [`cargo-mutants`](https://github.com/sourcefrog/cargo-mutants)
+- Code verification with [`Kani`](https://github.com/model-checking/kani)
 
-#### Attributes
+There are always more tests to write and more bugs to find. PRs are extremely welcomed.
+Please consider testing code as a first-class citizen. We definitely do take PRs
+improving and cleaning up test code.
 
-- `#[track_caller]`: Used on functions that panic on invalid arguments
-  (see https://rustc-dev-guide.rust-lang.org/backend/implicit-caller-location.html)
+### Unit/Integration tests
 
-- `#[cfg(rust_v_1_60)]`: Used to guard code that should only be built in if the toolchain is
-  compatible. These configuration conditionals are set at build time in `bitcoin/build.rs`. New
-  version attributes may be added as needed.
+Run as for any other Rust project `cargo test --all-features`.
 
+### Benchmarks
 
-#### Licensing
+We use a custom Rust compiler configuration conditional to guard the bench mark code. To run the
+bench marks use: `RUSTFLAGS='--cfg=bench' cargo +nightly bench`.
 
-We use SPDX license tags, all files should start with
+### Mutation tests
 
-```
-// SPDX-License-Identifier: CC0-1.0
-```
+We are doing mutation testing with [cargo-mutants](https://github.com/sourcefrog/cargo-mutants). To run
+these tests first install with `cargo install --locked cargo-mutants` then run with `cargo mutants --in-place --no-shuffle`.
+Note that running these mutation tests will take on the order of 10's of minutes.
 
-## Security
+### Code verification
 
-Security is the primary focus for this library; disclosure of security
-vulnerabilities helps prevent user loss of funds. If you believe a vulnerability
-may affect other implementations, please disclose this information according to
-the [security guidelines](./SECURITY.md), work on which is currently in progress.
-Before it is completed, feel free to send disclosure to Andrew Poelstra,
-apoelstra@wpsoftware.net, encrypted with his public key from
-<https://www.wpsoftware.net/andrew/andrew.gpg>.
+We have started using [kani](https://github.com/model-checking/kani), install with `cargo install --locked kani-verifier`
+ (no need to run `cargo kani setup`). Run the tests with `cargo kani`.
 
 
-## Testing
+## LLMs, GitHub bot accounts, and AI agents
 
-Related to the security aspect, rust bitcoin developers take testing very
-seriously. Due to the modular nature of the project, writing new test cases is
-easy and good test coverage of the codebase is an important goal. Refactoring
-the project to enable fine-grained unit testing is also an ongoing effort.
+This project does not accept contributions from bot GitHub accounts. All
+PRs that appear to come from such an account will be closed.
 
-Various methods of testing are in use (e.g. fuzzing, mutation), please see
-the [readme](./README.md) for more information.
+Patches created by LLMs and AI agents are also viewed with suspicion unless a
+human has reviewed them. All LLM generated patches MUST have text in the git log
+and in the PR description that indicates the patch was created using an LLM.
+First time contributions by way of LLM generated patches are not welcome. Thanks
+for your time, please be respectful of ours.
 
 
 ## Going further
diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 211aa646ab..faf2d41c59 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -10,17 +10,17 @@ checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
 [[package]]
 name = "base58ck"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
- "bitcoin_hashes 0.16.0",
- "hex-conservative 0.3.0",
+ "bitcoin_hashes",
+ "hex_lit",
 ]
 
 [[package]]
@@ -47,18 +47,19 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.33.0-alpha.0"
+version = "0.33.0-beta.0"
 dependencies = [
  "arbitrary",
  "base58ck",
  "base64",
  "bech32",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
- "bitcoin-io 0.2.0",
+ "bitcoin-io",
  "bitcoin-primitives",
  "bitcoin-units",
- "bitcoin_hashes 0.16.0",
+ "bitcoin_hashes",
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
@@ -72,19 +73,39 @@ dependencies = [
 name = "bitcoin-addresses"
 version = "0.0.0"
 
+[[package]]
+name = "bitcoin-bip158"
+version = "0.0.0"
+
+[[package]]
+name = "bitcoin-consensus-encoding"
+version = "1.0.0-rc.2"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative 0.3.0",
+]
+
+[[package]]
+name = "bitcoin-crypto"
+version = "0.0.0"
+
 [[package]]
 name = "bitcoin-fuzz"
 version = "0.0.1"
 dependencies = [
+ "arbitrary",
  "bitcoin",
+ "bitcoin-consensus-encoding",
+ "bitcoin-p2p-messages",
  "honggfuzz",
  "serde",
  "serde_json",
+ "standard_test",
 ]
 
 [[package]]
 name = "bitcoin-internals"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "bincode",
  "hex-conservative 0.3.0",
@@ -94,39 +115,53 @@ dependencies = [
 
 [[package]]
 name = "bitcoin-io"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+version = "0.3.0"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "bitcoin_hashes",
+]
 
 [[package]]
-name = "bitcoin-io"
-version = "0.2.0"
+name = "bitcoin-p2p-messages"
+version = "0.1.0"
 dependencies = [
+ "arbitrary",
+ "bitcoin",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
- "bitcoin_hashes 0.16.0",
+ "bitcoin-io",
+ "bitcoin-primitives",
+ "bitcoin-units",
+ "bitcoin_hashes",
+ "hex-conservative 0.3.0",
+ "hex_lit",
 ]
 
 [[package]]
 name = "bitcoin-primitives"
-version = "0.101.0"
+version = "1.0.0-rc.1"
 dependencies = [
  "arbitrary",
- "arrayvec",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "bitcoin-units",
- "bitcoin_hashes 0.16.0",
+ "bitcoin_hashes",
  "hex-conservative 0.3.0",
+ "hex-conservative 1.0.0",
+ "hex_lit",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "bitcoin-units"
-version = "0.2.0"
+version = "1.0.0-rc.3"
 dependencies = [
  "arbitrary",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "serde",
  "serde_json",
@@ -135,18 +170,9 @@ dependencies = [
 
 [[package]]
 name = "bitcoin_hashes"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
-dependencies = [
- "bitcoin-io 0.1.3",
- "hex-conservative 0.2.0",
-]
-
-[[package]]
-name = "bitcoin_hashes"
-version = "0.16.0"
+version = "0.18.0"
 dependencies = [
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "hex-conservative 0.3.0",
  "serde",
@@ -162,6 +188,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "bitflags"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+
 [[package]]
 name = "byteorder"
 version = "1.3.0"
@@ -176,9 +208,9 @@ checksum = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
 
 [[package]]
 name = "cfg-if"
-version = "0.1.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chacha20-poly1305"
@@ -189,33 +221,30 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee8025cf36f917e6a52cce185b7c7177689b838b7ec138364e50cc2277a56cf4"
+checksum = "71393ecc86efbf00e4ca13953979ba8b94cfe549a4b74cc26d8b62f4d8feac2b"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi",
+ "windows-targets",
 ]
 
 [[package]]
 name = "hex-conservative"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1aa273bf451e37ed35ced41c71a5e2a4e29064afb104158f2514bcd71c2c986"
+checksum = "4afe881d0527571892c4034822e59bb10c6c991cce6abe8199b6f5cf10766f55"
 dependencies = [
  "arrayvec",
 ]
 
 [[package]]
 name = "hex-conservative"
-version = "0.3.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4afe881d0527571892c4034822e59bb10c6c991cce6abe8199b6f5cf10766f55"
-dependencies = [
- "arrayvec",
- "serde",
-]
+checksum = "9ee770c000993d17c185713463d5ebfbd1af9afae4c17cc295640104383bfbf0"
 
 [[package]]
 name = "hex_lit"
@@ -225,13 +254,14 @@ checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
 
 [[package]]
 name = "honggfuzz"
-version = "0.5.56"
+version = "0.5.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c76b6234c13c9ea73946d1379d33186151148e0da231506b964b44f3d023505"
+checksum = "6e8319f3cc8fe416e7aa1ab95dcc04fd49f35397a47d0b2f0f225f6dba346a07"
 dependencies = [
  "lazy_static",
  "memmap2",
  "rustc_version",
+ "semver",
 ]
 
 [[package]]
@@ -242,9 +272,9 @@ checksum = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
@@ -254,54 +284,53 @@ checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "memmap2"
-version = "0.9.4"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
+checksum = "deaba38d7abf1d4cca21cc89e932e542ba2b9258664d2a9ef0e61512039c9375"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.8"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
+checksum = "c3ca011bd0129ff4ae15cd04c4eef202cadf6c51c21e47aba319b4e0501db741"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.63"
+version = "1.0.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+checksum = "2de98502f212cfcea8d0bb305bd0f49d7ebdd75b64ba0a68f937d888f4e0d6db"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.9"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "rand"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a76330fb486679b4ace3670f117bbc9e16204005c4bde9c4bd372f45bed34f12"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
 dependencies = [
- "libc",
  "rand_chacha",
  "rand_core",
- "rand_hc",
+ "zerocopy",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.3.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
  "rand_core",
@@ -309,20 +338,12 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.6.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"
+checksum = "b08f3c9802962f7e1b25113931d94f43ed9725bebc59db9d0c3e9a23b67e15ff"
 dependencies = [
  "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
-dependencies = [
- "rand_core",
+ "zerocopy",
 ]
 
 [[package]]
@@ -342,11 +363,10 @@ checksum = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997"
 
 [[package]]
 name = "secp256k1"
-version = "0.30.0"
+version = "0.32.0-beta.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+checksum = "3c5fdc7d6e800869d3fd60ff857c479bf0a83ea7bf44b389e64461e844204994"
 dependencies = [
- "bitcoin_hashes 0.14.0",
  "rand",
  "secp256k1-sys",
  "serde",
@@ -354,33 +374,33 @@ dependencies = [
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.10.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1433bd67156263443f14d603720b082dd3121779323fce20cba2aa07b874bc1b"
+checksum = "6d3be00697c88c00fe102af8dc316038cc2062eab8da646e7463f4c0e70ca9fd"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "semver"
-version = "1.0.17"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+checksum = "76b5842e81eb9bbea19276a9dbbda22ac042532f390a67ab08b895617978abf3"
 
 [[package]]
 name = "serde"
-version = "1.0.156"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.156"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -407,11 +427,20 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "standard_test"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af4bac6cd647192c3cb6e687af2703eb3a30e9187e555c664520cd848443ae70"
+dependencies = [
+ "arbitrary",
+]
+
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "89456b690ff72fddcecf231caedbe615c59480c93358a93dfae7fc29e3ebbf0e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -420,12 +449,99 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
 
 [[package]]
 name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
+version = "0.13.0+wasi-0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "652cd73449d0b957a2743b70c72d79d34a5fa505696488f4ca90b46f6da94118"
+dependencies = [
+ "bitflags",
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "026d24a27f6712541fa534f2954bd9e0eb66172f033c2157c0f31d106255c497"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df7885ffcb82507a0f213c593e77c5f13d12cb96588d4e835ad7e9423ba034db"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "930ad75608219e8ffdb8962a5433cb2b30064c7ccb564d3b76c2963390b1e435"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index e886abeca8..690a24f005 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -19,8 +19,8 @@ name = "base58ck"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
- "bitcoin_hashes 0.16.0",
- "hex-conservative 0.3.0",
+ "bitcoin_hashes",
+ "hex_lit",
 ]
 
 [[package]]
@@ -46,18 +46,19 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.33.0-alpha.0"
+version = "0.33.0-beta.0"
 dependencies = [
  "arbitrary",
  "base58ck",
  "base64",
  "bech32",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
- "bitcoin-io 0.2.0",
+ "bitcoin-io",
  "bitcoin-primitives",
  "bitcoin-units",
- "bitcoin_hashes 0.16.0",
+ "bitcoin_hashes",
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
@@ -71,19 +72,39 @@ dependencies = [
 name = "bitcoin-addresses"
 version = "0.0.0"
 
+[[package]]
+name = "bitcoin-bip158"
+version = "0.0.0"
+
+[[package]]
+name = "bitcoin-consensus-encoding"
+version = "1.0.0-rc.2"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative 0.3.0",
+]
+
+[[package]]
+name = "bitcoin-crypto"
+version = "0.0.0"
+
 [[package]]
 name = "bitcoin-fuzz"
 version = "0.0.1"
 dependencies = [
+ "arbitrary",
  "bitcoin",
+ "bitcoin-consensus-encoding",
+ "bitcoin-p2p-messages",
  "honggfuzz",
  "serde",
  "serde_json",
+ "standard_test",
 ]
 
 [[package]]
 name = "bitcoin-internals"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "bincode",
  "hex-conservative 0.3.0",
@@ -93,39 +114,53 @@ dependencies = [
 
 [[package]]
 name = "bitcoin-io"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+version = "0.3.0"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "bitcoin_hashes",
+]
 
 [[package]]
-name = "bitcoin-io"
-version = "0.2.0"
+name = "bitcoin-p2p-messages"
+version = "0.1.0"
 dependencies = [
+ "arbitrary",
+ "bitcoin",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
- "bitcoin_hashes 0.16.0",
+ "bitcoin-io",
+ "bitcoin-primitives",
+ "bitcoin-units",
+ "bitcoin_hashes",
+ "hex-conservative 0.3.0",
+ "hex_lit",
 ]
 
 [[package]]
 name = "bitcoin-primitives"
-version = "0.101.0"
+version = "1.0.0-rc.1"
 dependencies = [
  "arbitrary",
- "arrayvec",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "bitcoin-units",
- "bitcoin_hashes 0.16.0",
+ "bitcoin_hashes",
  "hex-conservative 0.3.0",
+ "hex-conservative 1.0.0",
+ "hex_lit",
  "serde",
  "serde_json",
 ]
 
 [[package]]
 name = "bitcoin-units"
-version = "0.2.0"
+version = "1.0.0-rc.3"
 dependencies = [
  "arbitrary",
  "bincode",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "serde",
  "serde_json",
@@ -134,18 +169,9 @@ dependencies = [
 
 [[package]]
 name = "bitcoin_hashes"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
-dependencies = [
- "bitcoin-io 0.1.3",
- "hex-conservative 0.2.1",
-]
-
-[[package]]
-name = "bitcoin_hashes"
-version = "0.16.0"
+version = "0.18.0"
 dependencies = [
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "hex-conservative 0.3.0",
  "serde",
@@ -191,33 +217,30 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi",
+ "r-efi",
+ "wasip2",
 ]
 
 [[package]]
 name = "hex-conservative"
-version = "0.2.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd"
+checksum = "4afe881d0527571892c4034822e59bb10c6c991cce6abe8199b6f5cf10766f55"
 dependencies = [
  "arrayvec",
 ]
 
 [[package]]
 name = "hex-conservative"
-version = "0.3.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4afe881d0527571892c4034822e59bb10c6c991cce6abe8199b6f5cf10766f55"
-dependencies = [
- "arrayvec",
- "serde",
-]
+checksum = "9ee770c000993d17c185713463d5ebfbd1af9afae4c17cc295640104383bfbf0"
 
 [[package]]
 name = "hex_lit"
@@ -227,13 +250,14 @@ checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
 
 [[package]]
 name = "honggfuzz"
-version = "0.5.56"
+version = "0.5.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c76b6234c13c9ea73946d1379d33186151148e0da231506b964b44f3d023505"
+checksum = "6e8319f3cc8fe416e7aa1ab95dcc04fd49f35397a47d0b2f0f225f6dba346a07"
 dependencies = [
  "lazy_static",
  "memmap2",
  "rustc_version",
+ "semver",
 ]
 
 [[package]]
@@ -296,22 +320,27 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "rand"
-version = "0.8.5"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "libc",
  "rand_chacha",
  "rand_core",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.3.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
  "rand_core",
@@ -319,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.6.4"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
  "getrandom",
 ]
@@ -343,11 +372,10 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "secp256k1"
-version = "0.30.0"
+version = "0.32.0-beta.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+checksum = "3c5fdc7d6e800869d3fd60ff857c479bf0a83ea7bf44b389e64461e844204994"
 dependencies = [
- "bitcoin_hashes 0.14.0",
  "rand",
  "secp256k1-sys",
  "serde",
@@ -355,9 +383,9 @@ dependencies = [
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.10.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+checksum = "6d3be00697c88c00fe102af8dc316038cc2062eab8da646e7463f4c0e70ca9fd"
 dependencies = [
  "cc",
 ]
@@ -415,6 +443,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "standard_test"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af4bac6cd647192c3cb6e687af2703eb3a30e9187e555c664520cd848443ae70"
+dependencies = [
+ "arbitrary",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.79"
@@ -433,10 +470,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
 name = "zerocopy"
diff --git a/Cargo.toml b/Cargo.toml
index 7d9a5d5264..e1efd3af10 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,136 @@
 [workspace]
-members = ["addresses", "base58", "bitcoin", "chacha20_poly1305", "fuzz", "hashes", "internals", "io", "primitives", "units"]
+members = ["addresses", "base58", "bip158", "bitcoin", "chacha20_poly1305", "consensus_encoding", "crypto", "fuzz", "hashes", "internals", "io", "p2p", "primitives", "units"]
+exclude = ["benches"]
 resolver = "2"
 
-# Keep this patch for hashes because secp256k1 depends on bitcoin-hashes via crates.io
-# This allows testing changes to hashes with secp256k1
-# See https://github.com/rust-bitcoin/rust-bitcoin/pull/4284#pullrequestreview-2714442229
-[patch.crates-io.bitcoin_hashes]
-path = "hashes"
+[workspace.lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
+
+[workspace.lints.clippy]
+# Exclude lints we don't think are valuable.
+needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+manual_range_contains = "allow" # More readable than clippy's format.
+# Exhaustive list of pedantic clippy lints
+assigning_clones = "warn"
+bool_to_int_with_if = "warn"
+borrow_as_ptr = "warn"
+case_sensitive_file_extension_comparisons = "warn"
+cast_lossless = "warn"
+cast_possible_truncation = "allow" # All casts should include a code comment (except test code).
+cast_possible_wrap = "allow" # Same as above re code comment.
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "allow" # All casts should include a code comment (except in test code).
+checked_conversions = "warn"
+cloned_instead_of_copied = "warn"
+copy_iterator = "warn"
+default_trait_access = "warn"
+doc_link_with_quotes = "warn"
+doc_markdown = "warn"
+empty_enum = "warn"
+enum_glob_use = "warn"
+expl_impl_clone_on_copy = "warn"
+explicit_deref_methods = "warn"
+explicit_into_iter_loop = "warn"
+explicit_iter_loop = "warn"
+filter_map_next = "warn"
+flat_map_option = "warn"
+float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
+fn_params_excessive_bools = "warn"
+from_iter_instead_of_collect = "warn"
+if_not_else = "warn"
+ignored_unit_patterns = "warn"
+implicit_clone = "warn"
+implicit_hasher = "warn"
+inconsistent_struct_constructor = "warn"
+index_refutable_slice = "warn"
+inefficient_to_string = "warn"
+inline_always = "warn"
+into_iter_without_iter = "warn"
+invalid_upcast_comparisons = "warn"
+items_after_statements = "warn"
+iter_filter_is_ok = "warn"
+iter_filter_is_some = "warn"
+iter_not_returning_iterator = "warn"
+iter_without_into_iter = "warn"
+large_digit_groups = "warn"
+large_futures = "warn"
+large_stack_arrays = "warn"
+large_types_passed_by_value = "warn"
+linkedlist = "warn"
+macro_use_imports = "warn"
+manual_assert = "warn"
+manual_instant_elapsed = "warn"
+manual_is_power_of_two = "warn"
+manual_is_variant_and = "warn"
+manual_let_else = "warn"
+manual_ok_or = "warn"
+manual_string_new = "warn"
+many_single_char_names = "warn"
+map_unwrap_or = "warn"
+match_bool = "allow" # Adds extra indentation and LOC.
+match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
+match_wild_err_arm = "warn"
+match_wildcard_for_single_variants = "warn"
+maybe_infinite_iter = "warn"
+mismatching_type_param_order = "warn"
+missing_errors_doc = "warn"
+missing_fields_in_debug = "warn"
+missing_panics_doc = "warn"
+must_use_candidate = "allow" # Useful for audit but many false positives.
+mut_mut = "warn"
+naive_bytecount = "warn"
+needless_bitwise_bool = "warn"
+needless_continue = "warn"
+needless_for_each = "warn"
+needless_pass_by_value = "warn"
+needless_raw_string_hashes = "warn"
+no_effect_underscore_binding = "warn"
+no_mangle_with_rust_abi = "warn"
+option_as_ref_cloned = "warn"
+option_option = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+pub_underscore_fields = "warn"
+range_minus_one = "warn"
+range_plus_one = "warn"
+redundant_clone = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+ref_as_ptr = "warn"
+ref_binding_to_reference = "warn"
+ref_option = "warn"
+ref_option_ref = "warn"
+return_self_not_must_use = "warn"
+same_functions_in_if_condition = "warn"
+semicolon_if_nothing_returned = "warn"
+should_panic_without_expect = "warn"
+similar_names = "allow" # Too many (subjectively) false positives.
+single_char_pattern = "warn"
+single_match_else = "warn"
+stable_sort_primitive = "warn"
+str_split_at_newline = "warn"
+string_add_assign = "warn"
+struct_excessive_bools = "warn"
+struct_field_names = "allow" # dumb
+too_many_lines = "warn"
+transmute_ptr_to_ptr = "warn"
+trivially_copy_pass_by_ref = "warn"
+unchecked_duration_subtraction = "warn"
+unicode_not_nfc = "warn"
+uninlined_format_args = "allow" # This is a subjective style choice.
+unnecessary_box_returns = "warn"
+unnecessary_join = "warn"
+unnecessary_literal_bound = "warn"
+unnecessary_wraps = "warn"
+unnested_or_patterns = "warn"
+unreadable_literal = "warn"
+unsafe_derive_deserialize = "warn"
+unused_async = "warn"
+unused_self = "warn"
+use_self = "warn"
+used_underscore_binding = "warn"
+used_underscore_items = "warn"
+verbose_bit_mask = "warn"
+wildcard_imports = "warn"
+zero_sized_map_values = "warn"
diff --git a/README.md b/README.md
index 1a287bdac3..5f32f528c3 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@
     <a href="https://github.com/rust-bitcoin/rust-bitcoin/blob/master/LICENSE"><img alt="CC0 1.0 Universal Licensed" src="https://img.shields.io/badge/license-CC0--1.0-blue.svg"/></a>
     <a href="https://github.com/rust-bitcoin/rust-bitcoin/actions?query=workflow%3AContinuous%20integration"><img alt="CI Status" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Continuous%20integration/badge.svg"></a>
     <a href="https://docs.rs/bitcoin"><img alt="API Docs" src="https://img.shields.io/badge/docs.rs-bitcoin-green"/></a>
-    <a href="https://blog.rust-lang.org/2022/08/11/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%2B-lightgrey.svg"/></a>
+    <a href="https://blog.rust-lang.org/2023/11/16/Rust-1.74.0/"><img alt="Rustc Version 1.74.0+" src="https://img.shields.io/badge/rustc-1.74.0%2B-lightgrey.svg"/></a>
     <a href="https://gnusha.org/bitcoin-rust/"><img alt="Chat on IRC" src="https://img.shields.io/badge/irc-%23bitcoin--rust%20on%20libera.chat-blue"></a>
     <a href="https://github.com/model-checking/kani"><img alt="kani" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Kani%20CI/badge.svg"></a>
   </p>
@@ -25,7 +25,7 @@ Supports (or should support)
 * De/serialization of Bitcoin protocol network messages
 * De/serialization of blocks and transactions
 * Script de/serialization
-* Private keys and address creation, de/serialization and validation (including full BIP32 support)
+* Private keys and address creation, de/serialization and validation (including full BIP-0032 support)
 * PSBT v0 de/serialization and all but the Input Finalizer role. Use [rust-miniscript](https://docs.rs/miniscript/latest/miniscript/psbt/index.html) to finalize.
 
 For JSONRPC interaction with Bitcoin Core, it is recommended to use
@@ -76,10 +76,19 @@ For more information, please see [`CONTRIBUTING.md`](./CONTRIBUTING.md).
 
 ## Minimum Supported Rust Version (MSRV)
 
-This library should compile with any combination of features on **Rust 1.63.0**.
+This library should compile with any combination of features on **Rust 1.74.0**.
 
 Use `Cargo-minimal.lock` to build the MSRV by copying to `Cargo.lock` and building.
 
+## No-std support
+
+The `std` cargo feature is enabled by default. To build this project without the Rust standard
+library, use the `--no-default-features` flag or set `default-features = false` in your dependency
+declaration when adding it to your project.
+
+For embedded device examples, see [`bitcoin/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/bitcoin/embedded)
+or [`hashes/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/hashes/embedded).
+
 ## External dependencies
 
 We integrate with a few external libraries, most notably `serde`. These
@@ -93,110 +102,6 @@ of "our CI didn't fail with these versions". Specifically, we do not guarantee
 that the committed hashes are free from malware. It is your responsibility to
 review them.
 
-## Installing Rust
-
-Rust can be installed using your package manager of choice or [rustup.rs](https://rustup.rs). The
-former way is considered more secure since it typically doesn't involve trust in the CA system. But
-you should be aware that the version of Rust shipped by your distribution might be out of date.
-Generally this isn't a problem for `rust-bitcoin` since we support much older versions than the
-current stable one (see MSRV section).
-
-## Building
-
-The library can be built and tested using [`cargo`](https://github.com/rust-lang/cargo/):
-
-```
-git clone git@github.com:rust-bitcoin/rust-bitcoin.git
-cd rust-bitcoin
-cargo build
-```
-
-You can run tests with:
-
-```
-cargo test
-```
-
-Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more
-detailed instructions.
-
-### No-std support
-
-The `std` cargo feature is enabled by default. To build this project without the Rust standard
-library, use the `--no-default-features` flag or set `default-features = false` in your dependency
-declaration when adding it to your project.
-
-For embedded device examples, see [`bitcoin/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/bitcoin/embedded)
-or [`hashes/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/hashes/embedded).
-
-### Just
-
-We support [`just`](https://just.systems/man/en/) for running dev workflow commands. Run `just` from
-your shell to see a list of available sub-commands.
-
-### Building the docs
-
-We build docs with the nightly toolchain, you may wish to use the following shell alias to check
-your documentation changes build correctly.
-
-```
-alias build-docs='RUSTDOCFLAGS="--cfg docsrs" cargo +nightly rustdoc --features="$FEATURES" -- -D rustdoc::broken-intra-doc-links'
-```
-
-## Testing
-
-Unit and integration tests are available for those interested, along with benchmarks. For project
-developers, especially new contributors looking for something to work on, we do:
-
-- Fuzz testing with [`Honggfuzz`](https://github.com/rust-fuzz/honggfuzz-rs)
-- Mutation testing with [`cargo-mutants`](https://github.com/sourcefrog/cargo-mutants)
-- Code verification with [`Kani`](https://github.com/model-checking/kani)
-
-There are always more tests to write and more bugs to find. PRs are extremely welcomed.
-Please consider testing code as a first-class citizen. We definitely do take PRs
-improving and cleaning up test code.
-
-### Unit/Integration tests
-
-Run as for any other Rust project `cargo test --all-features`.
-
-### Benchmarks
-
-We use a custom Rust compiler configuration conditional to guard the bench mark code. To run the
-bench marks use: `RUSTFLAGS='--cfg=bench' cargo +nightly bench`.
-
-### Mutation tests
-
-We are doing mutation testing with [cargo-mutants](https://github.com/sourcefrog/cargo-mutants). To run
-these tests first install with `cargo install --locked cargo-mutants` then run with `cargo mutants --in-place --no-shuffle`.
-Note that running these mutation tests will take on the order of 10's of minutes.
-
-### Code verification
-
-We have started using [kani](https://github.com/model-checking/kani), install with `cargo install --locked kani-verifier`
- (no need to run `cargo kani setup`). Run the tests with `cargo kani`.
-
-## Pull Requests
-
-Every PR needs at least two reviews to get merged. During the review phase, maintainers and
-contributors are likely to leave comments and request changes. Please try to address them, otherwise
-your PR might get closed without merging after a longer time of inactivity. If your PR isn't ready
-for review yet please mark it by prefixing the title with `WIP: `.
-
-### CI Pipeline
-
-The CI pipeline requires approval before being run on each MR.
-
-In order to speed up the review process the CI pipeline can be run locally using
-[act](https://github.com/nektos/act). The `fuzz` and `Cross` jobs will be skipped when using `act`
-due to caching being unsupported at this time. We do not *actively* support `act` but will merge PRs
-fixing `act` issues.
-
-### Githooks
-
-To assist devs in catching errors _before_ running CI we provide some githooks. Copy the hooks in `githooks/`
-to your githooks folder or run `just githooks-install` to copy them all.
-
 ## Policy on Altcoins/Altchains
 
 Since the altcoin landscape includes projects which [frequently appear and disappear, and are poorly
@@ -211,12 +116,17 @@ Our code is public domain so by all means fork it and go wild :)
 
 Release notes are done per crate, see:
 
-- [`bitcoin` CHANGELOG](bitcoin/CHANGELOG.md)
 - [`addresses` CHANGELOG](addresses/CHANGELOG.md)
 - [`base58` CHANGELOG](base58/CHANGELOG.md)
+- [`bip158` CHANGELOG](bip158/CHANGELOG.md)
+- [`bitcoin` CHANGELOG](bitcoin/CHANGELOG.md)
+- [`chacha20_poly1305` CHANGELOG](chacha20_poly1305/CHANGELOG.md)
+- [`consensus_encoding` CHANGELOG](consensus_encoding/CHANGELOG.md)
+- [`crypto` CHANGELOG](crypto/CHANGELOG.md)
 - [`hashes` CHANGELOG](hashes/CHANGELOG.md)
 - [`internals` CHANGELOG](internals/CHANGELOG.md)
 - [`io` CHANGELOG](io/CHANGELOG.md)
+- [`p2p` CHANGELOG](p2p/CHANGELOG.md)
 - [`primitives` CHANGELOG](primitives/CHANGELOG.md)
 - [`units` CHANGELOG](units/CHANGELOG.md)
 
diff --git a/addresses/Cargo.toml b/addresses/Cargo.toml
index 8e38252990..bc9066de22 100644
--- a/addresses/Cargo.toml
+++ b/addresses/Cargo.toml
@@ -9,7 +9,7 @@ categories = ["cryptography::cryptocurrencies"]
 keywords = ["bitcoin", "types"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
@@ -24,3 +24,7 @@ alloc = []
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/addresses/README.md b/addresses/README.md
index aaf09cc287..a7fdf225a1 100644
--- a/addresses/README.md
+++ b/addresses/README.md
@@ -1,7 +1,3 @@
 # Bitcoin Receive
 
 Types and logic required to receive bitcoin - i.e., bitcoin addresses.
-
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
diff --git a/addresses/contrib/extra_lints.sh b/addresses/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/addresses/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/addresses/src/lib.rs b/addresses/src/lib.rs
index 06c99f4e99..74884fd449 100644
--- a/addresses/src/lib.rs
+++ b/addresses/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Bitcoin Addresses
+//! Bitcoin Addresses
 //!
 //! Bitcoin addresses do not appear on chain; rather, they are conventions used by Bitcoin (wallet)
 //! software to communicate where coins should be sent and are based on the output type e.g., P2WPKH.
@@ -11,9 +11,8 @@
 
 // NB: This crate is empty if `alloc` is not enabled.
 #![cfg(feature = "alloc")]
-#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
+#![no_std]
 // Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![doc(test(attr(warn(unused))))]
 // Coding conventions.
 #![warn(deprecated_in_future)]
@@ -21,7 +20,7 @@
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 extern crate alloc;
 
diff --git a/api/consensus_encoding/all-features.txt b/api/consensus_encoding/all-features.txt
new file mode 100644
index 0000000000..ee67d857a9
--- /dev/null
+++ b/api/consensus_encoding/all-features.txt
@@ -0,0 +1,462 @@
+impl bitcoin_consensus_encoding::ByteVecDecoder
+impl bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::CompactSizeEncoder
+impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder
+impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::clone::Clone for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::clone::Clone for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::clone::Clone for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::Eq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::cmp::Eq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::Eq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::cmp::Eq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::default::Default for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::default::Default for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::error::Error for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::error::Error for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::error::Error for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::error::Error for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::fmt::Debug for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Debug for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::fmt::Debug for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::fmt::Display for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::fmt::Display for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Display for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::fmt::Display for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Freeze for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Freeze for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Send for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Send for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Send for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Send for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Sync for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Sync for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Sync for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Sync for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Unpin for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Unpin for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl<'e, T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::SliceEncoder<'e, T>
+impl<'e, T> core::marker::Freeze for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'e, T> core::marker::Send for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send, T: core::marker::Sync
+impl<'e, T> core::marker::Sync for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync, T: core::marker::Sync
+impl<'e, T> core::marker::Unpin for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'e, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'e, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> core::iter::traits::iterator::Iterator for bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T> core::marker::Freeze for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'s, T> core::marker::Send for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send
+impl<'s, T> core::marker::Sync for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync
+impl<'s, T> core::marker::Unpin for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'s, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe
+impl<'sl> bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Freeze for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Send for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Sync for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Unpin for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::error::Error for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static, E: core::error::Error + 'static, F: core::error::Error + 'static
+impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, C: core::marker::Freeze, F: core::marker::Freeze, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze, F: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Freeze, F: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, C: core::marker::Send, F: core::marker::Send, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, E: core::marker::Send, F: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Send, F: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, C: core::marker::Sync, F: core::marker::Sync, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync, F: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Sync, F: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, C: core::marker::Unpin, F: core::marker::Unpin, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin, F: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Unpin, F: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A, B, C, D> core::error::Error for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static
+impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A, B, C> core::error::Error for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static
+impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A, B> core::error::Error for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::error::Error + 'static, B: core::error::Error + 'static
+impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Send, B: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder, E: bitcoin_consensus_encoding::Encoder, F: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq, E: core::cmp::Eq, F: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::Eq, B: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::ReadError<D>
+impl<D: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::ReadError<D>
+impl<D> !core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ReadError<D>
+impl<D> !core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ReadError<D>
+impl<D> core::convert::From<std::io::error::Error> for bitcoin_consensus_encoding::ReadError<D>
+impl<D> core::error::Error for bitcoin_consensus_encoding::ReadError<D> where D: core::fmt::Debug + core::fmt::Display + core::error::Error + 'static
+impl<D> core::marker::Freeze for bitcoin_consensus_encoding::ReadError<D> where D: core::marker::Freeze
+impl<D> core::marker::Send for bitcoin_consensus_encoding::ReadError<D> where D: core::marker::Send
+impl<D> core::marker::Sync for bitcoin_consensus_encoding::ReadError<D> where D: core::marker::Sync
+impl<D> core::marker::Unpin for bitcoin_consensus_encoding::ReadError<D> where D: core::marker::Unpin
+impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::error::Error for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::error::Error + 'static
+impl<Err> core::fmt::Display for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::fmt::Display + core::fmt::Debug
+impl<Err> core::marker::Freeze for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Freeze
+impl<Err> core::marker::Send for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Send
+impl<Err> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::marker::Sync for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Sync
+impl<Err> core::marker::Unpin for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Unpin
+impl<Err> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::panic::unwind_safe::RefUnwindSafe
+impl<Err> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::panic::unwind_safe::UnwindSafe
+impl<T: bitcoin_consensus_encoding::Decodable> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Decodable> bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Decodable> core::default::Default for bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::SliceEncoder<'_, T>
+impl<T: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for core::option::Option<T>
+impl<T> core::marker::Freeze for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Send, T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Sync, T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Unpin, T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::panic::unwind_safe::RefUnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::panic::unwind_safe::UnwindSafe, T: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize> bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::default::Default for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+pub bitcoin_consensus_encoding::Decoder2Error::First(A)
+pub bitcoin_consensus_encoding::Decoder2Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::First(A)
+pub bitcoin_consensus_encoding::Decoder3Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder4Error::First(A)
+pub bitcoin_consensus_encoding::Decoder4Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder4Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder4Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder6Error::Fifth(E)
+pub bitcoin_consensus_encoding::Decoder6Error::First(A)
+pub bitcoin_consensus_encoding::Decoder6Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder6Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder6Error::Sixth(F)
+pub bitcoin_consensus_encoding::Decoder6Error::Third(C)
+pub bitcoin_consensus_encoding::ReadError::Decode(D)
+pub bitcoin_consensus_encoding::ReadError::Io(std::io::error::Error)
+pub const fn bitcoin_consensus_encoding::ArrayDecoder<N>::new() -> Self
+pub const fn bitcoin_consensus_encoding::ArrayEncoder<N>::without_length_prefix(arr: [u8; N]) -> Self
+pub const fn bitcoin_consensus_encoding::ByteVecDecoder::new() -> Self
+pub const fn bitcoin_consensus_encoding::BytesEncoder<'sl>::without_length_prefix(sl: &'sl [u8]) -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new() -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new_with_limit(limit: usize) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder2<A, B>::new(first: A, second: B) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder3<A, B, C>::new(dec_1: A, dec_2: B, dec_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D, dec_5: E, dec_6: F) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder2<A, B>::new(enc_1: A, enc_2: B) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder3<A, B, C>::new(enc_1: A, enc_2: B, enc_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D, enc_5: E, enc_6: F) -> Self
+pub const fn bitcoin_consensus_encoding::VecDecoder<T>::new() -> Self
+pub enum bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub enum bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub enum bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub enum bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub enum bitcoin_consensus_encoding::ReadError<D>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::default() -> Self
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::default() -> Self
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::clone(&self) -> bitcoin_consensus_encoding::ByteVecDecoderError
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::eq(&self, other: &bitcoin_consensus_encoding::ByteVecDecoderError) -> bool
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoder
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::default() -> Self
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoderError
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::eq(&self, other: &bitcoin_consensus_encoding::CompactSizeDecoderError) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::new(value: usize) -> Self
+pub fn bitcoin_consensus_encoding::Decodable::decoder() -> Self::Decoder
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::Decoder2Error<A, B>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::Decoder3Error<A, B, C>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::Decoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Encodable::encoder(&self) -> Self::Encoder
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::new(encodable: &'s T) -> Self
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::clone(&self) -> bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::eq(&self, other: &bitcoin_consensus_encoding::LengthPrefixExceedsMaxError) -> bool
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::ReadError<D>::from(e: std::io::error::Error) -> Self
+pub fn bitcoin_consensus_encoding::ReadError<D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::SliceEncoder<'e, T>::without_length_prefix(sl: &'e [T]) -> Self
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::clone(&self) -> bitcoin_consensus_encoding::UnexpectedEofError
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::eq(&self, other: &bitcoin_consensus_encoding::UnexpectedEofError) -> bool
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::default() -> Self
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::clone(&self) -> bitcoin_consensus_encoding::VecDecoderError<Err>
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::eq(&self, other: &bitcoin_consensus_encoding::VecDecoderError<Err>) -> bool
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_consensus_encoding::decode_from_read<T, R>(reader: R) -> core::result::Result<T, bitcoin_consensus_encoding::ReadError<<<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error>> where T: bitcoin_consensus_encoding::Decodable, R: std::io::BufRead
+pub fn bitcoin_consensus_encoding::decode_from_read_unbuffered<T, R>(reader: R) -> core::result::Result<T, bitcoin_consensus_encoding::ReadError<<<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error>> where T: bitcoin_consensus_encoding::Decodable, R: std::io::Read
+pub fn bitcoin_consensus_encoding::decode_from_read_unbuffered_with<T, R, const BUFFER_SIZE: usize>(reader: R) -> core::result::Result<T, bitcoin_consensus_encoding::ReadError<<<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error>> where T: bitcoin_consensus_encoding::Decodable, R: std::io::Read
+pub fn bitcoin_consensus_encoding::decode_from_slice<T>(bytes: &[u8]) -> core::result::Result<T, <<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error> where T: bitcoin_consensus_encoding::Decodable
+pub fn bitcoin_consensus_encoding::encode_to_vec<T>(object: &T) -> alloc::vec::Vec<u8> where T: bitcoin_consensus_encoding::Encodable + ?core::marker::Sized
+pub fn bitcoin_consensus_encoding::encode_to_writer<T, W>(object: &T, writer: W) -> core::result::Result<(), std::io::error::Error> where T: bitcoin_consensus_encoding::Encodable + ?core::marker::Sized, W: std::io::Write
+pub fn core::option::Option<T>::advance(&mut self) -> bool
+pub fn core::option::Option<T>::current_chunk(&self) -> &[u8]
+pub macro bitcoin_consensus_encoding::encoder_newtype!
+pub mod bitcoin_consensus_encoding
+pub struct bitcoin_consensus_encoding::ArrayDecoder<const N: usize>
+pub struct bitcoin_consensus_encoding::ArrayEncoder<const N: usize>
+pub struct bitcoin_consensus_encoding::ByteVecDecoder
+pub struct bitcoin_consensus_encoding::ByteVecDecoderError(_)
+pub struct bitcoin_consensus_encoding::BytesEncoder<'sl>
+pub struct bitcoin_consensus_encoding::CompactSizeDecoder
+pub struct bitcoin_consensus_encoding::CompactSizeDecoderError(_)
+pub struct bitcoin_consensus_encoding::CompactSizeEncoder
+pub struct bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::EncodableByteIter<'s, T: bitcoin_consensus_encoding::Encodable + 's>
+pub struct bitcoin_consensus_encoding::Encoder2<A, B>
+pub struct bitcoin_consensus_encoding::Encoder3<A, B, C>
+pub struct bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+pub struct bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+pub struct bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+pub struct bitcoin_consensus_encoding::SliceEncoder<'e, T: bitcoin_consensus_encoding::Encodable>
+pub struct bitcoin_consensus_encoding::UnexpectedEofError
+pub struct bitcoin_consensus_encoding::VecDecoder<T: bitcoin_consensus_encoding::Decodable>
+pub struct bitcoin_consensus_encoding::VecDecoderError<Err>(_)
+pub trait bitcoin_consensus_encoding::Decodable
+pub trait bitcoin_consensus_encoding::Decoder: core::marker::Sized
+pub trait bitcoin_consensus_encoding::Encodable
+pub trait bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = bitcoin_consensus_encoding::UnexpectedEofError
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Output = [u8; N]
+pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = bitcoin_consensus_encoding::ByteVecDecoderError
+pub type bitcoin_consensus_encoding::ByteVecDecoder::Output = alloc::vec::Vec<u8>
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = bitcoin_consensus_encoding::CompactSizeDecoderError
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Output = usize
+pub type bitcoin_consensus_encoding::Decodable::Decoder: bitcoin_consensus_encoding::Decoder<Output = Self>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Error = bitcoin_consensus_encoding::Decoder2Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Error = bitcoin_consensus_encoding::Decoder3Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Error = bitcoin_consensus_encoding::Decoder4Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Error = bitcoin_consensus_encoding::Decoder6Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error, <E as bitcoin_consensus_encoding::Decoder>::Error, <F as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output, <E as bitcoin_consensus_encoding::Decoder>::Output, <F as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder::Error
+pub type bitcoin_consensus_encoding::Decoder::Output
+pub type bitcoin_consensus_encoding::Encodable::Encoder<'s> where Self: 's: bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::EncodableByteIter<'s, T>::Item = u8
+pub type bitcoin_consensus_encoding::VecDecoder<T>::Error = bitcoin_consensus_encoding::VecDecoderError<<<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::VecDecoder<T>::Output = alloc::vec::Vec<T>
diff --git a/api/consensus_encoding/alloc-only.txt b/api/consensus_encoding/alloc-only.txt
new file mode 100644
index 0000000000..9b8591549b
--- /dev/null
+++ b/api/consensus_encoding/alloc-only.txt
@@ -0,0 +1,426 @@
+impl bitcoin_consensus_encoding::ByteVecDecoder
+impl bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::CompactSizeEncoder
+impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder
+impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::clone::Clone for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::clone::Clone for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::clone::Clone for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::Eq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::cmp::Eq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::Eq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::cmp::Eq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::default::Default for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::default::Default for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::fmt::Debug for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Debug for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::fmt::Debug for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::fmt::Display for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::fmt::Display for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Display for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::fmt::Display for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Freeze for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Freeze for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Send for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Send for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Send for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Send for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Sync for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Sync for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Sync for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Sync for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Unpin for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::marker::Unpin for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ByteVecDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl<'e, T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::SliceEncoder<'e, T>
+impl<'e, T> core::marker::Freeze for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'e, T> core::marker::Send for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send, T: core::marker::Sync
+impl<'e, T> core::marker::Sync for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync, T: core::marker::Sync
+impl<'e, T> core::marker::Unpin for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'e, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'e, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> core::iter::traits::iterator::Iterator for bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T> core::marker::Freeze for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'s, T> core::marker::Send for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send
+impl<'s, T> core::marker::Sync for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync
+impl<'s, T> core::marker::Unpin for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'s, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe
+impl<'sl> bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Freeze for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Send for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Sync for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Unpin for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, C: core::marker::Freeze, F: core::marker::Freeze, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze, F: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Freeze, F: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, C: core::marker::Send, F: core::marker::Send, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, E: core::marker::Send, F: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Send, F: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, C: core::marker::Sync, F: core::marker::Sync, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync, F: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Sync, F: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, C: core::marker::Unpin, F: core::marker::Unpin, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin, F: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Unpin, F: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Send, B: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder, E: bitcoin_consensus_encoding::Encoder, F: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq, E: core::cmp::Eq, F: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::Eq, B: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::fmt::Display for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::fmt::Display + core::fmt::Debug
+impl<Err> core::marker::Freeze for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Freeze
+impl<Err> core::marker::Send for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Send
+impl<Err> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::VecDecoderError<Err>
+impl<Err> core::marker::Sync for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Sync
+impl<Err> core::marker::Unpin for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::marker::Unpin
+impl<Err> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::panic::unwind_safe::RefUnwindSafe
+impl<Err> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::VecDecoderError<Err> where Err: core::panic::unwind_safe::UnwindSafe
+impl<T: bitcoin_consensus_encoding::Decodable> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Decodable> bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Decodable> core::default::Default for bitcoin_consensus_encoding::VecDecoder<T>
+impl<T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::SliceEncoder<'_, T>
+impl<T: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for core::option::Option<T>
+impl<T> core::marker::Freeze for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Send, T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Sync, T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::marker::Unpin, T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::panic::unwind_safe::RefUnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::VecDecoder<T> where <T as bitcoin_consensus_encoding::Decodable>::Decoder: core::panic::unwind_safe::UnwindSafe, T: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize> bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::default::Default for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+pub bitcoin_consensus_encoding::Decoder2Error::First(A)
+pub bitcoin_consensus_encoding::Decoder2Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::First(A)
+pub bitcoin_consensus_encoding::Decoder3Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder4Error::First(A)
+pub bitcoin_consensus_encoding::Decoder4Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder4Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder4Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder6Error::Fifth(E)
+pub bitcoin_consensus_encoding::Decoder6Error::First(A)
+pub bitcoin_consensus_encoding::Decoder6Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder6Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder6Error::Sixth(F)
+pub bitcoin_consensus_encoding::Decoder6Error::Third(C)
+pub const fn bitcoin_consensus_encoding::ArrayDecoder<N>::new() -> Self
+pub const fn bitcoin_consensus_encoding::ArrayEncoder<N>::without_length_prefix(arr: [u8; N]) -> Self
+pub const fn bitcoin_consensus_encoding::ByteVecDecoder::new() -> Self
+pub const fn bitcoin_consensus_encoding::BytesEncoder<'sl>::without_length_prefix(sl: &'sl [u8]) -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new() -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new_with_limit(limit: usize) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder2<A, B>::new(first: A, second: B) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder3<A, B, C>::new(dec_1: A, dec_2: B, dec_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D, dec_5: E, dec_6: F) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder2<A, B>::new(enc_1: A, enc_2: B) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder3<A, B, C>::new(enc_1: A, enc_2: B, enc_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D, enc_5: E, enc_6: F) -> Self
+pub const fn bitcoin_consensus_encoding::VecDecoder<T>::new() -> Self
+pub enum bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub enum bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub enum bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub enum bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::default() -> Self
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::default() -> Self
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::ByteVecDecoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::clone(&self) -> bitcoin_consensus_encoding::ByteVecDecoderError
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::eq(&self, other: &bitcoin_consensus_encoding::ByteVecDecoderError) -> bool
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::ByteVecDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoder
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::default() -> Self
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoderError
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::eq(&self, other: &bitcoin_consensus_encoding::CompactSizeDecoderError) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::new(value: usize) -> Self
+pub fn bitcoin_consensus_encoding::Decodable::decoder() -> Self::Decoder
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::Decoder2Error<A, B>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::Decoder3Error<A, B, C>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Encodable::encoder(&self) -> Self::Encoder
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::new(encodable: &'s T) -> Self
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::clone(&self) -> bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::eq(&self, other: &bitcoin_consensus_encoding::LengthPrefixExceedsMaxError) -> bool
+pub fn bitcoin_consensus_encoding::LengthPrefixExceedsMaxError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::SliceEncoder<'e, T>::without_length_prefix(sl: &'e [T]) -> Self
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::clone(&self) -> bitcoin_consensus_encoding::UnexpectedEofError
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::eq(&self, other: &bitcoin_consensus_encoding::UnexpectedEofError) -> bool
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::default() -> Self
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::VecDecoder<T>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::clone(&self) -> bitcoin_consensus_encoding::VecDecoderError<Err>
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::eq(&self, other: &bitcoin_consensus_encoding::VecDecoderError<Err>) -> bool
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::VecDecoderError<Err>::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_consensus_encoding::decode_from_slice<T>(bytes: &[u8]) -> core::result::Result<T, <<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error> where T: bitcoin_consensus_encoding::Decodable
+pub fn bitcoin_consensus_encoding::encode_to_vec<T>(object: &T) -> alloc::vec::Vec<u8> where T: bitcoin_consensus_encoding::Encodable + ?core::marker::Sized
+pub fn core::option::Option<T>::advance(&mut self) -> bool
+pub fn core::option::Option<T>::current_chunk(&self) -> &[u8]
+pub macro bitcoin_consensus_encoding::encoder_newtype!
+pub mod bitcoin_consensus_encoding
+pub struct bitcoin_consensus_encoding::ArrayDecoder<const N: usize>
+pub struct bitcoin_consensus_encoding::ArrayEncoder<const N: usize>
+pub struct bitcoin_consensus_encoding::ByteVecDecoder
+pub struct bitcoin_consensus_encoding::ByteVecDecoderError(_)
+pub struct bitcoin_consensus_encoding::BytesEncoder<'sl>
+pub struct bitcoin_consensus_encoding::CompactSizeDecoder
+pub struct bitcoin_consensus_encoding::CompactSizeDecoderError(_)
+pub struct bitcoin_consensus_encoding::CompactSizeEncoder
+pub struct bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::EncodableByteIter<'s, T: bitcoin_consensus_encoding::Encodable + 's>
+pub struct bitcoin_consensus_encoding::Encoder2<A, B>
+pub struct bitcoin_consensus_encoding::Encoder3<A, B, C>
+pub struct bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+pub struct bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+pub struct bitcoin_consensus_encoding::LengthPrefixExceedsMaxError
+pub struct bitcoin_consensus_encoding::SliceEncoder<'e, T: bitcoin_consensus_encoding::Encodable>
+pub struct bitcoin_consensus_encoding::UnexpectedEofError
+pub struct bitcoin_consensus_encoding::VecDecoder<T: bitcoin_consensus_encoding::Decodable>
+pub struct bitcoin_consensus_encoding::VecDecoderError<Err>(_)
+pub trait bitcoin_consensus_encoding::Decodable
+pub trait bitcoin_consensus_encoding::Decoder: core::marker::Sized
+pub trait bitcoin_consensus_encoding::Encodable
+pub trait bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = bitcoin_consensus_encoding::UnexpectedEofError
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Output = [u8; N]
+pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = bitcoin_consensus_encoding::ByteVecDecoderError
+pub type bitcoin_consensus_encoding::ByteVecDecoder::Output = alloc::vec::Vec<u8>
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = bitcoin_consensus_encoding::CompactSizeDecoderError
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Output = usize
+pub type bitcoin_consensus_encoding::Decodable::Decoder: bitcoin_consensus_encoding::Decoder<Output = Self>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Error = bitcoin_consensus_encoding::Decoder2Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Error = bitcoin_consensus_encoding::Decoder3Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Error = bitcoin_consensus_encoding::Decoder4Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Error = bitcoin_consensus_encoding::Decoder6Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error, <E as bitcoin_consensus_encoding::Decoder>::Error, <F as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output, <E as bitcoin_consensus_encoding::Decoder>::Output, <F as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder::Error
+pub type bitcoin_consensus_encoding::Decoder::Output
+pub type bitcoin_consensus_encoding::Encodable::Encoder<'s> where Self: 's: bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::EncodableByteIter<'s, T>::Item = u8
+pub type bitcoin_consensus_encoding::VecDecoder<T>::Error = bitcoin_consensus_encoding::VecDecoderError<<<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::VecDecoder<T>::Output = alloc::vec::Vec<T>
diff --git a/api/consensus_encoding/no-features.txt b/api/consensus_encoding/no-features.txt
new file mode 100644
index 0000000000..a11b460895
--- /dev/null
+++ b/api/consensus_encoding/no-features.txt
@@ -0,0 +1,339 @@
+impl bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::CompactSizeEncoder
+impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>
+impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::clone::Clone for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::Eq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::Eq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::default::Default for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Debug for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::fmt::Display for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::fmt::Display for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Freeze for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Send for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Sync for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::marker::Unpin for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::UnexpectedEofError
+impl<'e, T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::SliceEncoder<'e, T>
+impl<'e, T> core::marker::Freeze for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'e, T> core::marker::Send for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send, T: core::marker::Sync
+impl<'e, T> core::marker::Sync for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync, T: core::marker::Sync
+impl<'e, T> core::marker::Unpin for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'e, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'e, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::SliceEncoder<'e, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe, T: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T: bitcoin_consensus_encoding::Encodable + 's> core::iter::traits::iterator::Iterator for bitcoin_consensus_encoding::EncodableByteIter<'s, T>
+impl<'s, T> core::marker::Freeze for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Freeze
+impl<'s, T> core::marker::Send for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Send
+impl<'s, T> core::marker::Sync for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Sync
+impl<'s, T> core::marker::Unpin for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::marker::Unpin
+impl<'s, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::RefUnwindSafe
+impl<'s, T> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::EncodableByteIter<'s, T> where <T as bitcoin_consensus_encoding::Encodable>::Encoder: core::panic::unwind_safe::UnwindSafe
+impl<'sl> bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Freeze for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Send for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Sync for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::marker::Unpin for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<'sl> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D, E, F> bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, C: core::marker::Freeze, F: core::marker::Freeze, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze, F: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Freeze, F: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, C: core::marker::Send, F: core::marker::Send, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, E: core::marker::Send, F: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Send, F: core::marker::Send, A: core::marker::Send, B: core::marker::Send, D: core::marker::Send, E: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, C: core::marker::Sync, F: core::marker::Sync, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync, F: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Sync, F: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, C: core::marker::Unpin, F: core::marker::Unpin, <D as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <E as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin, F: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::marker::Unpin, F: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, <D as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <E as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F> where C: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+impl<A, B, C, D> bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, <C as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4<A, B, C, D> where <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, <C as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder4<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+impl<A, B, C> bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Freeze, A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Send, A: core::marker::Send, B: core::marker::Send
+impl<A, B, C> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Sync, A: core::marker::Sync, B: core::marker::Sync
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, <B as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::marker::Unpin, A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::RefUnwindSafe, A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, <B as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder3<A, B, C> where C: core::panic::unwind_safe::UnwindSafe, A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+impl<A, B> bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Send, B: core::marker::Send, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin, <A as bitcoin_consensus_encoding::Decoder>::Output: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, <A as bitcoin_consensus_encoding::Decoder>::Output: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Decoder2Error<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::Encoder2<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder, E: bitcoin_consensus_encoding::Encoder, F: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder, D: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder, C: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder3<A, B, C>
+impl<A: bitcoin_consensus_encoding::Encoder, B: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::Encoder2<A, B>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq, E: core::cmp::Eq, F: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::Eq, B: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::Decoder2Error<A, B>
+impl<T: bitcoin_consensus_encoding::Encodable> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::SliceEncoder<'_, T>
+impl<T: bitcoin_consensus_encoding::Encoder> bitcoin_consensus_encoding::Encoder for core::option::Option<T>
+impl<const N: usize> bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::default::Default for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::marker::Unpin for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
+impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
+pub bitcoin_consensus_encoding::Decoder2Error::First(A)
+pub bitcoin_consensus_encoding::Decoder2Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::First(A)
+pub bitcoin_consensus_encoding::Decoder3Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder3Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder4Error::First(A)
+pub bitcoin_consensus_encoding::Decoder4Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder4Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder4Error::Third(C)
+pub bitcoin_consensus_encoding::Decoder6Error::Fifth(E)
+pub bitcoin_consensus_encoding::Decoder6Error::First(A)
+pub bitcoin_consensus_encoding::Decoder6Error::Fourth(D)
+pub bitcoin_consensus_encoding::Decoder6Error::Second(B)
+pub bitcoin_consensus_encoding::Decoder6Error::Sixth(F)
+pub bitcoin_consensus_encoding::Decoder6Error::Third(C)
+pub const fn bitcoin_consensus_encoding::ArrayDecoder<N>::new() -> Self
+pub const fn bitcoin_consensus_encoding::ArrayEncoder<N>::without_length_prefix(arr: [u8; N]) -> Self
+pub const fn bitcoin_consensus_encoding::BytesEncoder<'sl>::without_length_prefix(sl: &'sl [u8]) -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new() -> Self
+pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new_with_limit(limit: usize) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder2<A, B>::new(first: A, second: B) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder3<A, B, C>::new(dec_1: A, dec_2: B, dec_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::new(dec_1: A, dec_2: B, dec_3: C, dec_4: D, dec_5: E, dec_6: F) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder2<A, B>::new(enc_1: A, enc_2: B) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder3<A, B, C>::new(enc_1: A, enc_2: B, enc_3: C) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D) -> Self
+pub const fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::new(enc_1: A, enc_2: B, enc_3: C, enc_4: D, enc_5: E, enc_6: F) -> Self
+pub enum bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub enum bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub enum bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub enum bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::default() -> Self
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoder
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::default() -> Self
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::CompactSizeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoderError
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::eq(&self, other: &bitcoin_consensus_encoding::CompactSizeDecoderError) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::CompactSizeEncoder::new(value: usize) -> Self
+pub fn bitcoin_consensus_encoding::Decodable::decoder() -> Self::Decoder
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder2<A, B>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::Decoder2Error<A, B>
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::Decoder2Error<A, B>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder3<A, B, C>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::Decoder3Error<A, B, C>
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::Decoder3Error<A, B, C>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder4<A, B, C, D>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>) -> bool
+pub fn bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::Decoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_consensus_encoding::Decoder::read_limit(&self) -> usize
+pub fn bitcoin_consensus_encoding::Encodable::encoder(&self) -> Self::Encoder
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::new(encodable: &'s T) -> Self
+pub fn bitcoin_consensus_encoding::EncodableByteIter<'s, T>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder2<A, B>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder3<A, B, C>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder4<A, B, C, D>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::Encoder::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::Encoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::advance(&mut self) -> bool
+pub fn bitcoin_consensus_encoding::SliceEncoder<'_, T>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_consensus_encoding::SliceEncoder<'e, T>::without_length_prefix(sl: &'e [T]) -> Self
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::clone(&self) -> bitcoin_consensus_encoding::UnexpectedEofError
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::eq(&self, other: &bitcoin_consensus_encoding::UnexpectedEofError) -> bool
+pub fn bitcoin_consensus_encoding::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_consensus_encoding::decode_from_slice<T>(bytes: &[u8]) -> core::result::Result<T, <<T as bitcoin_consensus_encoding::Decodable>::Decoder as bitcoin_consensus_encoding::Decoder>::Error> where T: bitcoin_consensus_encoding::Decodable
+pub fn core::option::Option<T>::advance(&mut self) -> bool
+pub fn core::option::Option<T>::current_chunk(&self) -> &[u8]
+pub macro bitcoin_consensus_encoding::encoder_newtype!
+pub mod bitcoin_consensus_encoding
+pub struct bitcoin_consensus_encoding::ArrayDecoder<const N: usize>
+pub struct bitcoin_consensus_encoding::ArrayEncoder<const N: usize>
+pub struct bitcoin_consensus_encoding::BytesEncoder<'sl>
+pub struct bitcoin_consensus_encoding::CompactSizeDecoder
+pub struct bitcoin_consensus_encoding::CompactSizeDecoderError(_)
+pub struct bitcoin_consensus_encoding::CompactSizeEncoder
+pub struct bitcoin_consensus_encoding::Decoder2<A, B> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder3<A, B, C> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder4<A, B, C, D> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F> where A: bitcoin_consensus_encoding::Decoder, B: bitcoin_consensus_encoding::Decoder, C: bitcoin_consensus_encoding::Decoder, D: bitcoin_consensus_encoding::Decoder, E: bitcoin_consensus_encoding::Decoder, F: bitcoin_consensus_encoding::Decoder
+pub struct bitcoin_consensus_encoding::EncodableByteIter<'s, T: bitcoin_consensus_encoding::Encodable + 's>
+pub struct bitcoin_consensus_encoding::Encoder2<A, B>
+pub struct bitcoin_consensus_encoding::Encoder3<A, B, C>
+pub struct bitcoin_consensus_encoding::Encoder4<A, B, C, D>
+pub struct bitcoin_consensus_encoding::Encoder6<A, B, C, D, E, F>
+pub struct bitcoin_consensus_encoding::SliceEncoder<'e, T: bitcoin_consensus_encoding::Encodable>
+pub struct bitcoin_consensus_encoding::UnexpectedEofError
+pub trait bitcoin_consensus_encoding::Decodable
+pub trait bitcoin_consensus_encoding::Decoder: core::marker::Sized
+pub trait bitcoin_consensus_encoding::Encodable
+pub trait bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = bitcoin_consensus_encoding::UnexpectedEofError
+pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Output = [u8; N]
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = bitcoin_consensus_encoding::CompactSizeDecoderError
+pub type bitcoin_consensus_encoding::CompactSizeDecoder::Output = usize
+pub type bitcoin_consensus_encoding::Decodable::Decoder: bitcoin_consensus_encoding::Decoder<Output = Self>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Error = bitcoin_consensus_encoding::Decoder2Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder2<A, B>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Error = bitcoin_consensus_encoding::Decoder3Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder3<A, B, C>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Error = bitcoin_consensus_encoding::Decoder4Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder4<A, B, C, D>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Error = bitcoin_consensus_encoding::Decoder6Error<<A as bitcoin_consensus_encoding::Decoder>::Error, <B as bitcoin_consensus_encoding::Decoder>::Error, <C as bitcoin_consensus_encoding::Decoder>::Error, <D as bitcoin_consensus_encoding::Decoder>::Error, <E as bitcoin_consensus_encoding::Decoder>::Error, <F as bitcoin_consensus_encoding::Decoder>::Error>
+pub type bitcoin_consensus_encoding::Decoder6<A, B, C, D, E, F>::Output = (<A as bitcoin_consensus_encoding::Decoder>::Output, <B as bitcoin_consensus_encoding::Decoder>::Output, <C as bitcoin_consensus_encoding::Decoder>::Output, <D as bitcoin_consensus_encoding::Decoder>::Output, <E as bitcoin_consensus_encoding::Decoder>::Output, <F as bitcoin_consensus_encoding::Decoder>::Output)
+pub type bitcoin_consensus_encoding::Decoder::Error
+pub type bitcoin_consensus_encoding::Decoder::Output
+pub type bitcoin_consensus_encoding::Encodable::Encoder<'s> where Self: 's: bitcoin_consensus_encoding::Encoder
+pub type bitcoin_consensus_encoding::EncodableByteIter<'s, T>::Item = u8
diff --git a/api/internals/all-features.txt b/api/internals/all-features.txt
new file mode 100644
index 0000000000..5e41c489a8
--- /dev/null
+++ b/api/internals/all-features.txt
@@ -0,0 +1,230 @@
+impl bitcoin_internals::ToU64 for u16
+impl bitcoin_internals::ToU64 for u32
+impl bitcoin_internals::ToU64 for u64
+impl bitcoin_internals::ToU64 for u8
+impl bitcoin_internals::ToU64 for usize
+impl bitcoin_internals::error::input_string::InputString
+impl bitcoin_internals::serde::IntoDeError for core::convert::Infallible
+impl bitcoin_internals::serde::IntoDeError for core::num::error::ParseIntError
+impl core::clone::Clone for bitcoin_internals::error::input_string::InputString
+impl core::clone::Clone for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Eq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Eq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Ord for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Ord for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialEq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialOrd for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialOrd for bitcoin_internals::script::PushDataLenLen
+impl core::convert::From<&str> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::borrow::Cow<'_, str>> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::boxed::Box<str>> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::string::String> for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::fmt::Debug for bitcoin_internals::script::PushDataLenLen
+impl core::hash::Hash for bitcoin_internals::error::input_string::InputString
+impl core::hash::Hash for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Copy for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Freeze for bitcoin_internals::error::input_string::InputString
+impl core::marker::Freeze for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Freeze for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Send for bitcoin_internals::error::input_string::InputString
+impl core::marker::Send for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Send for bitcoin_internals::script::PushDataLenLen
+impl core::marker::StructuralPartialEq for bitcoin_internals::error::input_string::InputString
+impl core::marker::StructuralPartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Sync for bitcoin_internals::error::input_string::InputString
+impl core::marker::Sync for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Sync for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Unpin for bitcoin_internals::error::input_string::InputString
+impl core::marker::Unpin for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Unpin for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl serde::ser::Serialize for bitcoin_internals::serde::SerializeBytesAsHex<'_>
+impl<'a, T> core::marker::Freeze for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::marker::Send for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Sync for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Unpin for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<'a> core::marker::Freeze for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<'a> core::marker::Send for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<'a> core::marker::Sync for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<'a> core::marker::Unpin for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::serde::SerializeBytesAsHex<'a>
+impl<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result> core::fmt::Debug for bitcoin_internals::wrap_debug::WrapDebug<F>
+impl<F> core::marker::Freeze for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Freeze
+impl<F> core::marker::Send for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Send
+impl<F> core::marker::Sync for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Sync
+impl<F> core::marker::Unpin for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Unpin
+impl<F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::RefUnwindSafe
+impl<F> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::UnwindSafe
+impl<T, const CAP: usize> core::marker::Freeze for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Freeze
+impl<T, const CAP: usize> core::marker::Send for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Send
+impl<T, const CAP: usize> core::marker::Sync for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Sync
+impl<T, const CAP: usize> core::marker::Unpin for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Unpin
+impl<T, const CAP: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T, const CAP: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::UnwindSafe
+impl<T: core::fmt::Display + ?core::marker::Sized> core::fmt::Display for bitcoin_internals::error::input_string::CannotParse<'_, T>
+impl<T: core::marker::Copy + core::cmp::Eq, const CAP: usize> core::cmp::Eq for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::Ord, const CAP: usize> core::cmp::Ord for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP1: usize, const CAP2: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<[T; LEN]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T; LEN]
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<[T]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T]
+impl<T: core::marker::Copy + core::cmp::PartialOrd, const CAP1: usize, const CAP2: usize> core::cmp::PartialOrd<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::fmt::Debug, const CAP: usize> core::fmt::Debug for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::hash::Hash, const CAP: usize> core::hash::Hash for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::marker::Copy, const CAP: usize> core::marker::Copy for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::clone::Clone for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::default::Default for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::Deref for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::DerefMut for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T> bitcoin_internals::slice::SliceExt for [T]
+impl<const N: usize, T> bitcoin_internals::array::ArrayExt for [T; N]
+pub bitcoin_internals::script::PushDataLenLen::Four = 4
+pub bitcoin_internals::script::PushDataLenLen::One = 1
+pub bitcoin_internals::script::PushDataLenLen::Two = 2
+pub const bitcoin_internals::compact_size::MAX_ENCODABLE_VALUE: u64
+pub const bitcoin_internals::compact_size::MAX_ENCODING_SIZE: usize
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_slice(&self) -> &[T]
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::from_slice(slice: &[T]) -> Self
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::new() -> Self
+pub const fn bitcoin_internals::compact_size::encoded_size_const(value: u64) -> usize
+pub const fn bitcoin_internals::const_casts::i16_to_i64(value: i16) -> i64
+pub const fn bitcoin_internals::const_casts::u16_to_u32(value: u16) -> u32
+pub const fn bitcoin_internals::const_casts::u16_to_u64(value: u16) -> u64
+pub const fn bitcoin_internals::const_casts::u32_to_u64(value: u32) -> u64
+pub enum bitcoin_internals::script::PushDataLenLen
+pub extern crate bitcoin_internals::bincode
+pub extern crate bitcoin_internals::serde_json
+pub fn [T; LEN]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T; N]::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn [T; N]::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn [T]::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn [T]::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn [T]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T]::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn [T]::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn [T]::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::ToU64::to_u64(self) -> u64
+pub fn bitcoin_internals::array::ArrayExt::first(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::get_static<const INDEX: usize>(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_first<const RIGHT: usize>(&self) -> (&Self::Item, &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_last<const LEFT: usize>(&self) -> (&Self::Item, &[Self::Item; LEFT])
+pub fn bitcoin_internals::array::ArrayExt::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::partial_cmp(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_mut_slice(&mut self) -> &mut [T]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::clone(&self) -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::default() -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref(&self) -> &Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T; LEN]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::extend_from_slice(&mut self, slice: &[T])
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::pop(&mut self) -> core::option::Option<T>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::push(&mut self, element: T)
+pub fn bitcoin_internals::compact_size::decode_unchecked(slice: &mut &[u8]) -> u64
+pub fn bitcoin_internals::compact_size::encode(value: impl bitcoin_internals::ToU64) -> bitcoin_internals::array_vec::ArrayVec<u8, MAX_ENCODING_SIZE>
+pub fn bitcoin_internals::compact_size::encoded_size(value: impl bitcoin_internals::ToU64) -> usize
+pub fn bitcoin_internals::error::input_string::CannotParse<'_, T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::clone(&self) -> bitcoin_internals::error::input_string::InputString
+pub fn bitcoin_internals::error::input_string::InputString::cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::cmp::Ordering
+pub fn bitcoin_internals::error::input_string::InputString::display_cannot_parse<'a, T>(&'a self, what: &'a T) -> bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::error::input_string::InputString::eq(&self, other: &bitcoin_internals::error::input_string::InputString) -> bool
+pub fn bitcoin_internals::error::input_string::InputString::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::from(input: &str) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::borrow::Cow<'_, str>) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::boxed::Box<str>) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::string::String) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::error::input_string::InputString::partial_cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::error::input_string::InputString::unknown_variant<T>(&self, what: &T, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::script::EarlyEndOfScriptError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::clone(&self) -> bitcoin_internals::script::PushDataLenLen
+pub fn bitcoin_internals::script::PushDataLenLen::cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::cmp::Ordering
+pub fn bitcoin_internals::script::PushDataLenLen::eq(&self, other: &bitcoin_internals::script::PushDataLenLen) -> bool
+pub fn bitcoin_internals::script::PushDataLenLen::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::script::PushDataLenLen::partial_cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::script::read_push_data_len(data: &mut core::slice::iter::Iter<'_, u8>, size: bitcoin_internals::script::PushDataLenLen) -> core::result::Result<usize, bitcoin_internals::script::EarlyEndOfScriptError>
+pub fn bitcoin_internals::serde::IntoDeError::into_de_error<E: serde::de::Error>(self, expected: core::option::Option<&dyn serde::de::Expected>) -> E
+pub fn bitcoin_internals::serde::IntoDeError::try_into_de_error<E>(self, expected: core::option::Option<&dyn serde::de::Expected>) -> core::result::Result<E, Self> where E: serde::de::Error
+pub fn bitcoin_internals::serde::SerializeBytesAsHex<'_>::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn bitcoin_internals::slice::SliceExt::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn bitcoin_internals::slice::SliceExt::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::wrap_debug::WrapDebug<F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn core::convert::Infallible::into_de_error<E: serde::de::Error>(self, _expected: core::option::Option<&dyn serde::de::Expected>) -> E
+pub fn core::num::error::ParseIntError::into_de_error<E: serde::de::Error>(self, expected: core::option::Option<&dyn serde::de::Expected>) -> E
+pub fn core::num::error::ParseIntError::try_into_de_error<E>(self, expected: core::option::Option<&dyn serde::de::Expected>) -> core::result::Result<E, Self> where E: serde::de::Error
+pub fn u16::to_u64(self) -> u64
+pub fn u32::to_u64(self) -> u64
+pub fn u64::to_u64(self) -> u64
+pub fn u8::to_u64(self) -> u64
+pub fn usize::to_u64(self) -> u64
+pub macro bitcoin_internals::concat_bytes_to_arr!
+pub macro bitcoin_internals::cond_const!
+pub macro bitcoin_internals::const_assert!
+pub macro bitcoin_internals::const_tools::concat_bytes_to_arr!
+pub macro bitcoin_internals::const_tools::cond_const!
+pub macro bitcoin_internals::const_tools::copy_byte_array_from_slice!
+pub macro bitcoin_internals::copy_byte_array_from_slice!
+pub macro bitcoin_internals::impl_array_newtype!
+pub macro bitcoin_internals::impl_parse!
+pub macro bitcoin_internals::impl_parse_and_serde!
+pub macro bitcoin_internals::impl_to_hex_from_lower_hex!
+pub macro bitcoin_internals::parse_error_type!
+pub macro bitcoin_internals::rust_version!
+pub macro bitcoin_internals::serde_round_trip!
+pub macro bitcoin_internals::serde_string_deserialize_impl!
+pub macro bitcoin_internals::serde_string_impl!
+pub macro bitcoin_internals::serde_string_serialize_impl!
+pub macro bitcoin_internals::serde_struct_human_string_impl!
+pub macro bitcoin_internals::transparent_newtype!
+pub macro bitcoin_internals::write_err!
+pub mod bitcoin_internals
+pub mod bitcoin_internals::array
+pub mod bitcoin_internals::array_vec
+pub mod bitcoin_internals::compact_size
+pub mod bitcoin_internals::const_casts
+pub mod bitcoin_internals::const_tools
+pub mod bitcoin_internals::error
+pub mod bitcoin_internals::error::input_string
+pub mod bitcoin_internals::macros
+pub mod bitcoin_internals::script
+pub mod bitcoin_internals::serde
+pub mod bitcoin_internals::slice
+pub mod bitcoin_internals::wrap_debug
+pub struct bitcoin_internals::array_vec::ArrayVec<T: core::marker::Copy, const CAP: usize>
+pub struct bitcoin_internals::error::InputString(_)
+pub struct bitcoin_internals::error::input_string::CannotParse<'a, T: core::fmt::Display + ?core::marker::Sized>
+pub struct bitcoin_internals::error::input_string::InputString(_)
+pub struct bitcoin_internals::script::EarlyEndOfScriptError
+pub struct bitcoin_internals::serde::SerializeBytesAsHex<'a>(pub &'a [u8])
+pub struct bitcoin_internals::wrap_debug::WrapDebug<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result>(pub F)
+pub trait bitcoin_internals::ToU64
+pub trait bitcoin_internals::array::ArrayExt
+pub trait bitcoin_internals::serde::IntoDeError: core::marker::Sized
+pub trait bitcoin_internals::slice::SliceExt
+pub type [T; N]::Item = T
+pub type [T]::Item = T
+pub type bitcoin_internals::array::ArrayExt::Item
+pub type bitcoin_internals::array_vec::ArrayVec<T, CAP>::Target = [T]
+pub type bitcoin_internals::slice::SliceExt::Item
diff --git a/api/internals/alloc-only.txt b/api/internals/alloc-only.txt
new file mode 100644
index 0000000000..11461afd2b
--- /dev/null
+++ b/api/internals/alloc-only.txt
@@ -0,0 +1,205 @@
+impl bitcoin_internals::ToU64 for u16
+impl bitcoin_internals::ToU64 for u32
+impl bitcoin_internals::ToU64 for u64
+impl bitcoin_internals::ToU64 for u8
+impl bitcoin_internals::ToU64 for usize
+impl bitcoin_internals::error::input_string::InputString
+impl core::clone::Clone for bitcoin_internals::error::input_string::InputString
+impl core::clone::Clone for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Eq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Eq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Ord for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Ord for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialEq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialOrd for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialOrd for bitcoin_internals::script::PushDataLenLen
+impl core::convert::From<&str> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::borrow::Cow<'_, str>> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::boxed::Box<str>> for bitcoin_internals::error::input_string::InputString
+impl core::convert::From<alloc::string::String> for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::fmt::Debug for bitcoin_internals::script::PushDataLenLen
+impl core::hash::Hash for bitcoin_internals::error::input_string::InputString
+impl core::hash::Hash for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Copy for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Freeze for bitcoin_internals::error::input_string::InputString
+impl core::marker::Freeze for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Freeze for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Send for bitcoin_internals::error::input_string::InputString
+impl core::marker::Send for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Send for bitcoin_internals::script::PushDataLenLen
+impl core::marker::StructuralPartialEq for bitcoin_internals::error::input_string::InputString
+impl core::marker::StructuralPartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Sync for bitcoin_internals::error::input_string::InputString
+impl core::marker::Sync for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Sync for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Unpin for bitcoin_internals::error::input_string::InputString
+impl core::marker::Unpin for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Unpin for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl<'a, T> core::marker::Freeze for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::marker::Send for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Sync for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Unpin for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result> core::fmt::Debug for bitcoin_internals::wrap_debug::WrapDebug<F>
+impl<F> core::marker::Freeze for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Freeze
+impl<F> core::marker::Send for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Send
+impl<F> core::marker::Sync for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Sync
+impl<F> core::marker::Unpin for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Unpin
+impl<F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::RefUnwindSafe
+impl<F> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::UnwindSafe
+impl<T, const CAP: usize> core::marker::Freeze for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Freeze
+impl<T, const CAP: usize> core::marker::Send for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Send
+impl<T, const CAP: usize> core::marker::Sync for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Sync
+impl<T, const CAP: usize> core::marker::Unpin for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Unpin
+impl<T, const CAP: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T, const CAP: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::UnwindSafe
+impl<T: core::fmt::Display + ?core::marker::Sized> core::fmt::Display for bitcoin_internals::error::input_string::CannotParse<'_, T>
+impl<T: core::marker::Copy + core::cmp::Eq, const CAP: usize> core::cmp::Eq for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::Ord, const CAP: usize> core::cmp::Ord for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP1: usize, const CAP2: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<[T; LEN]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T; LEN]
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<[T]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T]
+impl<T: core::marker::Copy + core::cmp::PartialOrd, const CAP1: usize, const CAP2: usize> core::cmp::PartialOrd<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::fmt::Debug, const CAP: usize> core::fmt::Debug for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::hash::Hash, const CAP: usize> core::hash::Hash for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::marker::Copy, const CAP: usize> core::marker::Copy for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::clone::Clone for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::default::Default for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::Deref for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::DerefMut for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T> bitcoin_internals::slice::SliceExt for [T]
+impl<const N: usize, T> bitcoin_internals::array::ArrayExt for [T; N]
+pub bitcoin_internals::script::PushDataLenLen::Four = 4
+pub bitcoin_internals::script::PushDataLenLen::One = 1
+pub bitcoin_internals::script::PushDataLenLen::Two = 2
+pub const bitcoin_internals::compact_size::MAX_ENCODABLE_VALUE: u64
+pub const bitcoin_internals::compact_size::MAX_ENCODING_SIZE: usize
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_slice(&self) -> &[T]
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::from_slice(slice: &[T]) -> Self
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::new() -> Self
+pub const fn bitcoin_internals::compact_size::encoded_size_const(value: u64) -> usize
+pub const fn bitcoin_internals::const_casts::i16_to_i64(value: i16) -> i64
+pub const fn bitcoin_internals::const_casts::u16_to_u32(value: u16) -> u32
+pub const fn bitcoin_internals::const_casts::u16_to_u64(value: u16) -> u64
+pub const fn bitcoin_internals::const_casts::u32_to_u64(value: u32) -> u64
+pub enum bitcoin_internals::script::PushDataLenLen
+pub fn [T; LEN]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T; N]::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn [T; N]::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn [T]::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn [T]::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn [T]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T]::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn [T]::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn [T]::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::ToU64::to_u64(self) -> u64
+pub fn bitcoin_internals::array::ArrayExt::first(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::get_static<const INDEX: usize>(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_first<const RIGHT: usize>(&self) -> (&Self::Item, &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_last<const LEFT: usize>(&self) -> (&Self::Item, &[Self::Item; LEFT])
+pub fn bitcoin_internals::array::ArrayExt::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::partial_cmp(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_mut_slice(&mut self) -> &mut [T]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::clone(&self) -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::default() -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref(&self) -> &Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T; LEN]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::extend_from_slice(&mut self, slice: &[T])
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::pop(&mut self) -> core::option::Option<T>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::push(&mut self, element: T)
+pub fn bitcoin_internals::compact_size::decode_unchecked(slice: &mut &[u8]) -> u64
+pub fn bitcoin_internals::compact_size::encode(value: impl bitcoin_internals::ToU64) -> bitcoin_internals::array_vec::ArrayVec<u8, MAX_ENCODING_SIZE>
+pub fn bitcoin_internals::compact_size::encoded_size(value: impl bitcoin_internals::ToU64) -> usize
+pub fn bitcoin_internals::error::input_string::CannotParse<'_, T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::clone(&self) -> bitcoin_internals::error::input_string::InputString
+pub fn bitcoin_internals::error::input_string::InputString::cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::cmp::Ordering
+pub fn bitcoin_internals::error::input_string::InputString::display_cannot_parse<'a, T>(&'a self, what: &'a T) -> bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::error::input_string::InputString::eq(&self, other: &bitcoin_internals::error::input_string::InputString) -> bool
+pub fn bitcoin_internals::error::input_string::InputString::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::from(input: &str) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::borrow::Cow<'_, str>) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::boxed::Box<str>) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::from(input: alloc::string::String) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::error::input_string::InputString::partial_cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::error::input_string::InputString::unknown_variant<T>(&self, what: &T, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::script::EarlyEndOfScriptError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::clone(&self) -> bitcoin_internals::script::PushDataLenLen
+pub fn bitcoin_internals::script::PushDataLenLen::cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::cmp::Ordering
+pub fn bitcoin_internals::script::PushDataLenLen::eq(&self, other: &bitcoin_internals::script::PushDataLenLen) -> bool
+pub fn bitcoin_internals::script::PushDataLenLen::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::script::PushDataLenLen::partial_cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::script::read_push_data_len(data: &mut core::slice::iter::Iter<'_, u8>, size: bitcoin_internals::script::PushDataLenLen) -> core::result::Result<usize, bitcoin_internals::script::EarlyEndOfScriptError>
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn bitcoin_internals::slice::SliceExt::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn bitcoin_internals::slice::SliceExt::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::wrap_debug::WrapDebug<F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn u16::to_u64(self) -> u64
+pub fn u32::to_u64(self) -> u64
+pub fn u64::to_u64(self) -> u64
+pub fn u8::to_u64(self) -> u64
+pub fn usize::to_u64(self) -> u64
+pub macro bitcoin_internals::concat_bytes_to_arr!
+pub macro bitcoin_internals::cond_const!
+pub macro bitcoin_internals::const_assert!
+pub macro bitcoin_internals::const_tools::concat_bytes_to_arr!
+pub macro bitcoin_internals::const_tools::cond_const!
+pub macro bitcoin_internals::const_tools::copy_byte_array_from_slice!
+pub macro bitcoin_internals::copy_byte_array_from_slice!
+pub macro bitcoin_internals::impl_array_newtype!
+pub macro bitcoin_internals::impl_parse!
+pub macro bitcoin_internals::impl_parse_and_serde!
+pub macro bitcoin_internals::impl_to_hex_from_lower_hex!
+pub macro bitcoin_internals::parse_error_type!
+pub macro bitcoin_internals::rust_version!
+pub macro bitcoin_internals::transparent_newtype!
+pub macro bitcoin_internals::write_err!
+pub mod bitcoin_internals
+pub mod bitcoin_internals::array
+pub mod bitcoin_internals::array_vec
+pub mod bitcoin_internals::compact_size
+pub mod bitcoin_internals::const_casts
+pub mod bitcoin_internals::const_tools
+pub mod bitcoin_internals::error
+pub mod bitcoin_internals::error::input_string
+pub mod bitcoin_internals::macros
+pub mod bitcoin_internals::script
+pub mod bitcoin_internals::slice
+pub mod bitcoin_internals::wrap_debug
+pub struct bitcoin_internals::array_vec::ArrayVec<T: core::marker::Copy, const CAP: usize>
+pub struct bitcoin_internals::error::InputString(_)
+pub struct bitcoin_internals::error::input_string::CannotParse<'a, T: core::fmt::Display + ?core::marker::Sized>
+pub struct bitcoin_internals::error::input_string::InputString(_)
+pub struct bitcoin_internals::script::EarlyEndOfScriptError
+pub struct bitcoin_internals::wrap_debug::WrapDebug<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result>(pub F)
+pub trait bitcoin_internals::ToU64
+pub trait bitcoin_internals::array::ArrayExt
+pub trait bitcoin_internals::slice::SliceExt
+pub type [T; N]::Item = T
+pub type [T]::Item = T
+pub type bitcoin_internals::array::ArrayExt::Item
+pub type bitcoin_internals::array_vec::ArrayVec<T, CAP>::Target = [T]
+pub type bitcoin_internals::slice::SliceExt::Item
diff --git a/api/internals/no-features.txt b/api/internals/no-features.txt
new file mode 100644
index 0000000000..2e5175c096
--- /dev/null
+++ b/api/internals/no-features.txt
@@ -0,0 +1,199 @@
+impl bitcoin_internals::ToU64 for u16
+impl bitcoin_internals::ToU64 for u32
+impl bitcoin_internals::ToU64 for u64
+impl bitcoin_internals::ToU64 for u8
+impl bitcoin_internals::ToU64 for usize
+impl bitcoin_internals::error::input_string::InputString
+impl core::clone::Clone for bitcoin_internals::error::input_string::InputString
+impl core::clone::Clone for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Eq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Eq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::Ord for bitcoin_internals::error::input_string::InputString
+impl core::cmp::Ord for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialEq for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::cmp::PartialOrd for bitcoin_internals::error::input_string::InputString
+impl core::cmp::PartialOrd for bitcoin_internals::script::PushDataLenLen
+impl core::convert::From<&str> for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::error::input_string::InputString
+impl core::fmt::Debug for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::fmt::Debug for bitcoin_internals::script::PushDataLenLen
+impl core::hash::Hash for bitcoin_internals::error::input_string::InputString
+impl core::hash::Hash for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Copy for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Freeze for bitcoin_internals::error::input_string::InputString
+impl core::marker::Freeze for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Freeze for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Send for bitcoin_internals::error::input_string::InputString
+impl core::marker::Send for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Send for bitcoin_internals::script::PushDataLenLen
+impl core::marker::StructuralPartialEq for bitcoin_internals::error::input_string::InputString
+impl core::marker::StructuralPartialEq for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Sync for bitcoin_internals::error::input_string::InputString
+impl core::marker::Sync for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Sync for bitcoin_internals::script::PushDataLenLen
+impl core::marker::Unpin for bitcoin_internals::error::input_string::InputString
+impl core::marker::Unpin for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::marker::Unpin for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::InputString
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::EarlyEndOfScriptError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_internals::script::PushDataLenLen
+impl<'a, T> core::marker::Freeze for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::marker::Send for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Sync for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::marker::Sync + ?core::marker::Sized
+impl<'a, T> core::marker::Unpin for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<'a, T> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result> core::fmt::Debug for bitcoin_internals::wrap_debug::WrapDebug<F>
+impl<F> core::marker::Freeze for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Freeze
+impl<F> core::marker::Send for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Send
+impl<F> core::marker::Sync for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Sync
+impl<F> core::marker::Unpin for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::marker::Unpin
+impl<F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::RefUnwindSafe
+impl<F> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::wrap_debug::WrapDebug<F> where F: core::panic::unwind_safe::UnwindSafe
+impl<T, const CAP: usize> core::marker::Freeze for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Freeze
+impl<T, const CAP: usize> core::marker::Send for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Send
+impl<T, const CAP: usize> core::marker::Sync for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Sync
+impl<T, const CAP: usize> core::marker::Unpin for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::marker::Unpin
+impl<T, const CAP: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T, const CAP: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_internals::array_vec::ArrayVec<T, CAP> where T: core::panic::unwind_safe::UnwindSafe
+impl<T: core::fmt::Display + ?core::marker::Sized> core::fmt::Display for bitcoin_internals::error::input_string::CannotParse<'_, T>
+impl<T: core::marker::Copy + core::cmp::Eq, const CAP: usize> core::cmp::Eq for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::Ord, const CAP: usize> core::cmp::Ord for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP1: usize, const CAP2: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<[T; LEN]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize, const LEN: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T; LEN]
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<[T]> for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::cmp::PartialEq, const CAP: usize> core::cmp::PartialEq<bitcoin_internals::array_vec::ArrayVec<T, CAP>> for [T]
+impl<T: core::marker::Copy + core::cmp::PartialOrd, const CAP1: usize, const CAP2: usize> core::cmp::PartialOrd<bitcoin_internals::array_vec::ArrayVec<T, CAP2>> for bitcoin_internals::array_vec::ArrayVec<T, CAP1>
+impl<T: core::marker::Copy + core::fmt::Debug, const CAP: usize> core::fmt::Debug for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::hash::Hash, const CAP: usize> core::hash::Hash for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy + core::marker::Copy, const CAP: usize> core::marker::Copy for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::clone::Clone for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::default::Default for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::Deref for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T: core::marker::Copy, const CAP: usize> core::ops::deref::DerefMut for bitcoin_internals::array_vec::ArrayVec<T, CAP>
+impl<T> bitcoin_internals::slice::SliceExt for [T]
+impl<const N: usize, T> bitcoin_internals::array::ArrayExt for [T; N]
+pub bitcoin_internals::script::PushDataLenLen::Four = 4
+pub bitcoin_internals::script::PushDataLenLen::One = 1
+pub bitcoin_internals::script::PushDataLenLen::Two = 2
+pub const bitcoin_internals::compact_size::MAX_ENCODABLE_VALUE: u64
+pub const bitcoin_internals::compact_size::MAX_ENCODING_SIZE: usize
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_slice(&self) -> &[T]
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::from_slice(slice: &[T]) -> Self
+pub const fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::new() -> Self
+pub const fn bitcoin_internals::compact_size::encoded_size_const(value: u64) -> usize
+pub const fn bitcoin_internals::const_casts::i16_to_i64(value: i16) -> i64
+pub const fn bitcoin_internals::const_casts::u16_to_u32(value: u16) -> u32
+pub const fn bitcoin_internals::const_casts::u16_to_u64(value: u16) -> u64
+pub const fn bitcoin_internals::const_casts::u32_to_u64(value: u32) -> u64
+pub enum bitcoin_internals::script::PushDataLenLen
+pub fn [T; LEN]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T; N]::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn [T; N]::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn [T]::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn [T]::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn [T]::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP>) -> bool
+pub fn [T]::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn [T]::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn [T]::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::ToU64::to_u64(self) -> u64
+pub fn bitcoin_internals::array::ArrayExt::first(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::get_static<const INDEX: usize>(&self) -> &Self::Item
+pub fn bitcoin_internals::array::ArrayExt::split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_first<const RIGHT: usize>(&self) -> (&Self::Item, &[Self::Item; RIGHT])
+pub fn bitcoin_internals::array::ArrayExt::split_last<const LEFT: usize>(&self) -> (&Self::Item, &[Self::Item; LEFT])
+pub fn bitcoin_internals::array::ArrayExt::sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::eq(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP1>::partial_cmp(&self, other: &bitcoin_internals::array_vec::ArrayVec<T, CAP2>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::as_mut_slice(&mut self) -> &mut [T]
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::clone(&self) -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::default() -> Self
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref(&self) -> &Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T; LEN]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::eq(&self, other: &[T]) -> bool
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::extend_from_slice(&mut self, slice: &[T])
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::hash<H: core::hash::Hasher>(&self, state: &mut H)
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::pop(&mut self) -> core::option::Option<T>
+pub fn bitcoin_internals::array_vec::ArrayVec<T, CAP>::push(&mut self, element: T)
+pub fn bitcoin_internals::compact_size::decode_unchecked(slice: &mut &[u8]) -> u64
+pub fn bitcoin_internals::compact_size::encode(value: impl bitcoin_internals::ToU64) -> bitcoin_internals::array_vec::ArrayVec<u8, MAX_ENCODING_SIZE>
+pub fn bitcoin_internals::compact_size::encoded_size(value: impl bitcoin_internals::ToU64) -> usize
+pub fn bitcoin_internals::error::input_string::CannotParse<'_, T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::clone(&self) -> bitcoin_internals::error::input_string::InputString
+pub fn bitcoin_internals::error::input_string::InputString::cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::cmp::Ordering
+pub fn bitcoin_internals::error::input_string::InputString::display_cannot_parse<'a, T>(&'a self, what: &'a T) -> bitcoin_internals::error::input_string::CannotParse<'a, T> where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::error::input_string::InputString::eq(&self, other: &bitcoin_internals::error::input_string::InputString) -> bool
+pub fn bitcoin_internals::error::input_string::InputString::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::error::input_string::InputString::from(input: &str) -> Self
+pub fn bitcoin_internals::error::input_string::InputString::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::error::input_string::InputString::partial_cmp(&self, other: &bitcoin_internals::error::input_string::InputString) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::error::input_string::InputString::unknown_variant<T>(&self, what: &T, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result where T: core::fmt::Display + ?core::marker::Sized
+pub fn bitcoin_internals::script::EarlyEndOfScriptError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::clone(&self) -> bitcoin_internals::script::PushDataLenLen
+pub fn bitcoin_internals::script::PushDataLenLen::cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::cmp::Ordering
+pub fn bitcoin_internals::script::PushDataLenLen::eq(&self, other: &bitcoin_internals::script::PushDataLenLen) -> bool
+pub fn bitcoin_internals::script::PushDataLenLen::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_internals::script::PushDataLenLen::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_internals::script::PushDataLenLen::partial_cmp(&self, other: &bitcoin_internals::script::PushDataLenLen) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_internals::script::read_push_data_len(data: &mut core::slice::iter::Iter<'_, u8>, size: bitcoin_internals::script::PushDataLenLen) -> core::result::Result<usize, bitcoin_internals::script::EarlyEndOfScriptError>
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item])
+pub fn bitcoin_internals::slice::SliceExt::get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> core::option::Option<&[Self::Item; ARRAY_LEN]>
+pub fn bitcoin_internals::slice::SliceExt::split_first_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>
+pub fn bitcoin_internals::slice::SliceExt::split_last_chunk<const ARRAY_LEN: usize>(&self) -> core::option::Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>
+pub fn bitcoin_internals::wrap_debug::WrapDebug<F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn u16::to_u64(self) -> u64
+pub fn u32::to_u64(self) -> u64
+pub fn u64::to_u64(self) -> u64
+pub fn u8::to_u64(self) -> u64
+pub fn usize::to_u64(self) -> u64
+pub macro bitcoin_internals::concat_bytes_to_arr!
+pub macro bitcoin_internals::cond_const!
+pub macro bitcoin_internals::const_assert!
+pub macro bitcoin_internals::const_tools::concat_bytes_to_arr!
+pub macro bitcoin_internals::const_tools::cond_const!
+pub macro bitcoin_internals::const_tools::copy_byte_array_from_slice!
+pub macro bitcoin_internals::copy_byte_array_from_slice!
+pub macro bitcoin_internals::impl_array_newtype!
+pub macro bitcoin_internals::impl_parse!
+pub macro bitcoin_internals::impl_parse_and_serde!
+pub macro bitcoin_internals::impl_to_hex_from_lower_hex!
+pub macro bitcoin_internals::parse_error_type!
+pub macro bitcoin_internals::rust_version!
+pub macro bitcoin_internals::transparent_newtype!
+pub macro bitcoin_internals::write_err!
+pub mod bitcoin_internals
+pub mod bitcoin_internals::array
+pub mod bitcoin_internals::array_vec
+pub mod bitcoin_internals::compact_size
+pub mod bitcoin_internals::const_casts
+pub mod bitcoin_internals::const_tools
+pub mod bitcoin_internals::error
+pub mod bitcoin_internals::error::input_string
+pub mod bitcoin_internals::macros
+pub mod bitcoin_internals::script
+pub mod bitcoin_internals::slice
+pub mod bitcoin_internals::wrap_debug
+pub struct bitcoin_internals::array_vec::ArrayVec<T: core::marker::Copy, const CAP: usize>
+pub struct bitcoin_internals::error::InputString(_)
+pub struct bitcoin_internals::error::input_string::CannotParse<'a, T: core::fmt::Display + ?core::marker::Sized>
+pub struct bitcoin_internals::error::input_string::InputString(_)
+pub struct bitcoin_internals::script::EarlyEndOfScriptError
+pub struct bitcoin_internals::wrap_debug::WrapDebug<F: core::ops::function::Fn(&mut core::fmt::Formatter<'_>) -> core::fmt::Result>(pub F)
+pub trait bitcoin_internals::ToU64
+pub trait bitcoin_internals::array::ArrayExt
+pub trait bitcoin_internals::slice::SliceExt
+pub type [T; N]::Item = T
+pub type [T]::Item = T
+pub type bitcoin_internals::array::ArrayExt::Item
+pub type bitcoin_internals::array_vec::ArrayVec<T, CAP>::Target = [T]
+pub type bitcoin_internals::slice::SliceExt::Item
diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
new file mode 100644
index 0000000000..bd3927650a
--- /dev/null
+++ b/api/primitives/all-features.txt
@@ -0,0 +1,2116 @@
+#[non_exhaustive] pub enum bitcoin_primitives::block::HeaderDecoderError
+#[non_exhaustive] pub enum bitcoin_primitives::block::InvalidBlockError
+#[non_exhaustive] pub enum bitcoin_primitives::transaction::ParseOutPointError
+#[repr(transparent)] pub struct bitcoin_primitives::script::Script<T>(_, _)
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Block
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Header
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::Transaction
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::TxIn
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::TxOut
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::witness::Witness
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::BlockDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::HeaderDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::VersionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TransactionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxInDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxOutDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::VersionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::witness::WitnessDecoder
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Block
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Header
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::Transaction
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::TxIn
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::TxOut
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::witness::Witness
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::BlockHashEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::HeaderEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::VersionEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::pow::CompactTargetEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::VersionEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::WitnessesEncoder<'_>
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::witness::WitnessEncoder<'_>
+impl bitcoin_primitives::BlockHash
+impl bitcoin_primitives::Ntxid
+impl bitcoin_primitives::TxMerkleNode
+impl bitcoin_primitives::Txid
+impl bitcoin_primitives::WitnessCommitment
+impl bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_primitives::Wtxid
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+impl bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::VersionDecoder
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_primitives::script::RedeemScriptSizeError
+impl bitcoin_primitives::script::ScriptHash
+impl bitcoin_primitives::script::ScriptHashableTag for bitcoin_primitives::script::RedeemScriptTag
+impl bitcoin_primitives::script::ScriptHashableTag for bitcoin_primitives::script::ScriptPubKeyTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::RedeemScriptTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::ScriptPubKeyTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::ScriptSigTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::TapScriptTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::WitnessScriptTag
+impl bitcoin_primitives::script::WScriptHash
+impl bitcoin_primitives::script::WitnessScriptSizeError
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_primitives::transaction::Transaction
+impl bitcoin_primitives::transaction::TransactionDecoder
+impl bitcoin_primitives::transaction::TxIn
+impl bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::VersionDecoder
+impl bitcoin_primitives::witness::Witness
+impl bitcoin_primitives::witness::WitnessDecoder
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::BlockHash
+impl core::clone::Clone for bitcoin_primitives::Ntxid
+impl core::clone::Clone for bitcoin_primitives::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Txid
+impl core::clone::Clone for bitcoin_primitives::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Wtxid
+impl core::clone::Clone for bitcoin_primitives::block::BlockDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::BlockHashDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::Checked
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::HeaderDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::InvalidBlockError
+impl core::clone::Clone for bitcoin_primitives::block::Unchecked
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::VersionDecoderError
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptTag
+impl core::clone::Clone for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::clone::Clone for bitcoin_primitives::script::ScriptSigTag
+impl core::clone::Clone for bitcoin_primitives::script::TapScriptTag
+impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptTag
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::ParseOutPointError
+impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
+impl core::clone::Clone for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
+impl core::clone::Clone for bitcoin_primitives::transaction::TxInDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::VersionDecoderError
+impl core::clone::Clone for bitcoin_primitives::witness::UnexpectedEofError
+impl core::clone::Clone for bitcoin_primitives::witness::Witness
+impl core::clone::Clone for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::Eq for bitcoin_primitives::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::Ntxid
+impl core::cmp::Eq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Txid
+impl core::cmp::Eq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::block::BlockDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::Checked
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::HeaderDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::InvalidBlockError
+impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::Eq for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Eq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::cmp::Eq for bitcoin_primitives::witness::Witness
+impl core::cmp::Eq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::Ord for bitcoin_primitives::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::Ntxid
+impl core::cmp::Ord for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Txid
+impl core::cmp::Ord for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::block::Checked
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::Ord for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::Ord for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::Ntxid
+impl core::cmp::PartialEq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::HeaderDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::InvalidBlockError
+impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::PartialOrd for bitcoin_primitives::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::Ntxid
+impl core::cmp::PartialOrd for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
+impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
+impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::BlockHash
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Txid
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Wtxid
+impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::ByteVecDecoderError> for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxInDecoderError>> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxOutDecoderError>> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Txid
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Wtxid
+impl core::convert::From<bitcoin_primitives::transaction::Version> for u32
+impl core::convert::From<bitcoin_primitives::transaction::VersionDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_primitives::witness::WitnessDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_units::locktime::absolute::error::LockTimeDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::BlockDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::HeaderDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::InvalidBlockError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxInDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::VersionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::witness::WitnessDecoderError
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::default::Default for bitcoin_primitives::block::BlockHashDecoder
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::block::VersionDecoder
+impl core::default::Default for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::default::Default for bitcoin_primitives::transaction::OutPointDecoder
+impl core::default::Default for bitcoin_primitives::transaction::TransactionDecoder
+impl core::default::Default for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::default::Default for bitcoin_primitives::transaction::VersionDecoder
+impl core::default::Default for bitcoin_primitives::witness::Witness
+impl core::default::Default for bitcoin_primitives::witness::WitnessDecoder
+impl core::error::Error for bitcoin_primitives::block::BlockDecoderError
+impl core::error::Error for bitcoin_primitives::block::BlockHashDecoderError
+impl core::error::Error for bitcoin_primitives::block::HeaderDecoderError
+impl core::error::Error for bitcoin_primitives::block::InvalidBlockError
+impl core::error::Error for bitcoin_primitives::block::VersionDecoderError
+impl core::error::Error for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::error::Error for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::error::Error for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::error::Error for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::error::Error for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::error::Error for bitcoin_primitives::transaction::ParseOutPointError
+impl core::error::Error for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::error::Error for bitcoin_primitives::transaction::TxInDecoderError
+impl core::error::Error for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::error::Error for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::error::Error for bitcoin_primitives::transaction::VersionDecoderError
+impl core::error::Error for bitcoin_primitives::witness::UnexpectedEofError
+impl core::error::Error for bitcoin_primitives::witness::WitnessDecoderError
+impl core::fmt::Debug for bitcoin_primitives::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::Ntxid
+impl core::fmt::Debug for bitcoin_primitives::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Txid
+impl core::fmt::Debug for bitcoin_primitives::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Wtxid
+impl core::fmt::Debug for bitcoin_primitives::block::BlockDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::Checked
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::HeaderDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::InvalidBlockError
+impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
+impl core::fmt::Debug for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxInDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::witness::UnexpectedEofError
+impl core::fmt::Debug for bitcoin_primitives::witness::Witness
+impl core::fmt::Debug for bitcoin_primitives::witness::WitnessDecoderError
+impl core::fmt::Display for bitcoin_primitives::BlockHash
+impl core::fmt::Display for bitcoin_primitives::Ntxid
+impl core::fmt::Display for bitcoin_primitives::TxMerkleNode
+impl core::fmt::Display for bitcoin_primitives::Txid
+impl core::fmt::Display for bitcoin_primitives::WitnessCommitment
+impl core::fmt::Display for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::Display for bitcoin_primitives::Wtxid
+impl core::fmt::Display for bitcoin_primitives::block::BlockDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::Header
+impl core::fmt::Display for bitcoin_primitives::block::HeaderDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::InvalidBlockError
+impl core::fmt::Display for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::fmt::Display for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::fmt::Display for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Display for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxInDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::witness::UnexpectedEofError
+impl core::fmt::Display for bitcoin_primitives::witness::WitnessDecoderError
+impl core::fmt::LowerHex for bitcoin_primitives::BlockHash
+impl core::fmt::LowerHex for bitcoin_primitives::Ntxid
+impl core::fmt::LowerHex for bitcoin_primitives::TxMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::Txid
+impl core::fmt::LowerHex for bitcoin_primitives::WitnessCommitment
+impl core::fmt::LowerHex for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::Wtxid
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::LowerHex for bitcoin_primitives::script::WScriptHash
+impl core::fmt::UpperHex for bitcoin_primitives::BlockHash
+impl core::fmt::UpperHex for bitcoin_primitives::Ntxid
+impl core::fmt::UpperHex for bitcoin_primitives::TxMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::Txid
+impl core::fmt::UpperHex for bitcoin_primitives::WitnessCommitment
+impl core::fmt::UpperHex for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::Wtxid
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::UpperHex for bitcoin_primitives::script::WScriptHash
+impl core::hash::Hash for bitcoin_primitives::BlockHash
+impl core::hash::Hash for bitcoin_primitives::Ntxid
+impl core::hash::Hash for bitcoin_primitives::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Txid
+impl core::hash::Hash for bitcoin_primitives::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::Checked
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Unchecked
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::script::RedeemScriptTag
+impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::hash::Hash for bitcoin_primitives::script::ScriptSigTag
+impl core::hash::Hash for bitcoin_primitives::script::TapScriptTag
+impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::WitnessScriptTag
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
+impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
+impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::hash::Hash for bitcoin_primitives::witness::Witness
+impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
+impl core::marker::Copy for bitcoin_primitives::BlockHash
+impl core::marker::Copy for bitcoin_primitives::Ntxid
+impl core::marker::Copy for bitcoin_primitives::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Txid
+impl core::marker::Copy for bitcoin_primitives::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Wtxid
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
+impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::Ntxid
+impl core::marker::Freeze for bitcoin_primitives::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Txid
+impl core::marker::Freeze for bitcoin_primitives::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::Checked
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Freeze for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
+impl core::marker::Freeze for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Freeze for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Freeze for bitcoin_primitives::witness::Witness
+impl core::marker::Freeze for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Freeze for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Send for bitcoin_primitives::BlockHash
+impl core::marker::Send for bitcoin_primitives::Ntxid
+impl core::marker::Send for bitcoin_primitives::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::Txid
+impl core::marker::Send for bitcoin_primitives::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::Wtxid
+impl core::marker::Send for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Send for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Send for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Send for bitcoin_primitives::block::Checked
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Send for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Send for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Send for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Send for bitcoin_primitives::block::Unchecked
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Send for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Send for bitcoin_primitives::script::ScriptHash
+impl core::marker::Send for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Send for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Send for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Send for bitcoin_primitives::script::WScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Send for bitcoin_primitives::transaction::Transaction
+impl core::marker::Send for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxIn
+impl core::marker::Send for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxOut
+impl core::marker::Send for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Send for bitcoin_primitives::witness::Witness
+impl core::marker::Send for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Send for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Ntxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::TapScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Sync for bitcoin_primitives::BlockHash
+impl core::marker::Sync for bitcoin_primitives::Ntxid
+impl core::marker::Sync for bitcoin_primitives::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Txid
+impl core::marker::Sync for bitcoin_primitives::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Wtxid
+impl core::marker::Sync for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Sync for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Sync for bitcoin_primitives::block::Checked
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Sync for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Sync for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Sync for bitcoin_primitives::block::Unchecked
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Sync for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Sync for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Sync for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
+impl core::marker::Sync for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
+impl core::marker::Sync for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Sync for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Sync for bitcoin_primitives::witness::Witness
+impl core::marker::Sync for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Sync for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Unpin for bitcoin_primitives::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::Ntxid
+impl core::marker::Unpin for bitcoin_primitives::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Txid
+impl core::marker::Unpin for bitcoin_primitives::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::Checked
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Unpin for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
+impl core::marker::Unpin for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Unpin for bitcoin_primitives::witness::Witness
+impl core::marker::Unpin for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Unpin for bitcoin_primitives::witness::WitnessDecoderError
+impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::InvalidBlockError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptSigTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::TapScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::UnexpectedEofError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::InvalidBlockError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptSigTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::TapScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::UnexpectedEofError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessDecoderError
+impl core::str::traits::FromStr for bitcoin_primitives::BlockHash
+impl core::str::traits::FromStr for bitcoin_primitives::Ntxid
+impl core::str::traits::FromStr for bitcoin_primitives::TxMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::Txid
+impl core::str::traits::FromStr for bitcoin_primitives::WitnessCommitment
+impl core::str::traits::FromStr for bitcoin_primitives::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::Wtxid
+impl core::str::traits::FromStr for bitcoin_primitives::script::ScriptHash
+impl core::str::traits::FromStr for bitcoin_primitives::script::WScriptHash
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::OutPoint
+impl serde::ser::Serialize for bitcoin_primitives::BlockHash
+impl serde::ser::Serialize for bitcoin_primitives::Ntxid
+impl serde::ser::Serialize for bitcoin_primitives::TxMerkleNode
+impl serde::ser::Serialize for bitcoin_primitives::Txid
+impl serde::ser::Serialize for bitcoin_primitives::WitnessCommitment
+impl serde::ser::Serialize for bitcoin_primitives::WitnessMerkleNode
+impl serde::ser::Serialize for bitcoin_primitives::Wtxid
+impl serde::ser::Serialize for bitcoin_primitives::block::Version
+impl serde::ser::Serialize for bitcoin_primitives::pow::CompactTarget
+impl serde::ser::Serialize for bitcoin_primitives::script::ScriptHash
+impl serde::ser::Serialize for bitcoin_primitives::script::WScriptHash
+impl serde::ser::Serialize for bitcoin_primitives::transaction::OutPoint
+impl serde::ser::Serialize for bitcoin_primitives::transaction::Version
+impl serde::ser::Serialize for bitcoin_primitives::witness::Witness
+impl<'a, T> arbitrary::Arbitrary<'a> for &'a bitcoin_primitives::script::Script<T>
+impl<'a, T> arbitrary::Arbitrary<'a> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::rc::Rc<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::sync::Arc<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'a, T> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::BlockHash
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::Ntxid
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::TxMerkleNode
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::Txid
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::WitnessCommitment
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::WitnessMerkleNode
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::Wtxid
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Block
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Header
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Version
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::script::ScriptHash
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::script::WScriptHash
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::OutPoint
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Transaction
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxIn
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxOut
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Version
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::witness::Witness
+impl<'a> core::clone::Clone for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
+impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'de, T> serde::de::Deserialize<'de> for &'de bitcoin_primitives::script::Script<T>
+impl<'de, T> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::BlockHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::Ntxid
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::TxMerkleNode
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::Txid
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::WitnessCommitment
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::WitnessMerkleNode
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::Wtxid
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::Version
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::pow::CompactTarget
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::WScriptHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::OutPoint
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Version
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::witness::Witness
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<T: 'static> core::default::Default for &bitcoin_primitives::script::Script<T>
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<&bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<&[T]> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<[T]> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::boxed::Box<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::rc::Rc<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::sync::Arc<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::vec::Vec<T>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for &[T]
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for [T]
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::boxed::Box<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::rc::Rc<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::sync::Arc<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::vec::Vec<T>
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::Ord> core::cmp::Ord for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::Ord> core::cmp::Ord for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::Script<T>
+impl<T: core::convert::AsRef<[u8]>> core::iter::traits::collect::FromIterator<T> for bitcoin_primitives::witness::Witness
+impl<T: core::hash::Hash> core::hash::Hash for bitcoin_primitives::script::Script<T>
+impl<T: core::hash::Hash> core::hash::Hash for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> !core::marker::Sized for bitcoin_primitives::script::Script<T>
+impl<T> alloc::borrow::ToOwned for bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_primitives::script::ScriptBuf<T>
+impl<T> bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::borrow::Borrow<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::borrow::BorrowMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsRef<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsRef<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script<T>>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::vec::Vec<u8>
+impl<T> core::default::Default for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::default::Default for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::fmt::Debug for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::Debug for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::fmt::Display for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::Display for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::fmt::LowerHex for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::fmt::UpperHex for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::Script<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::marker::Send for bitcoin_primitives::script::Script<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_primitives::script::Script<T>
+impl<T> core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Sync for bitcoin_primitives::script::Script<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_primitives::script::Script<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Unpin
+impl<T> core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> serde::ser::Serialize for bitcoin_primitives::script::Script<T>
+impl<T> serde::ser::Serialize for bitcoin_primitives::script::ScriptBuf<T>
+impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
+impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
+impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
+impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
+impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
+impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
+impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<&[T; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<[T; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for &[T; N]
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for [T; N]
+impl<const N: usize, const M: usize> core::convert::From<&[&[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<&[[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<[&[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<[[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[&[u8; N]]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[&[u8]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[[u8; N]]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<[&[u8]; N]> for bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::BlockHeader::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::OutPoint::vout: u32
+pub bitcoin_primitives::Transaction::inputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::Transaction::lock_time: bitcoin_units::locktime::absolute::LockTime
+pub bitcoin_primitives::Transaction::outputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptSigBuf
+pub bitcoin_primitives::TxIn::sequence: bitcoin_units::sequence::Sequence
+pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::TxOut::amount: bitcoin_units::amount::unsigned::encapsulate::Amount
+pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptPubKeyBuf
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::block::Header::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::block::HeaderDecoderError::Bits(bitcoin_primitives::pow::CompactTargetDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::MerkleRoot(bitcoin_primitives::transaction::TxMerkleNodeDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Nonce(bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError)
+pub bitcoin_primitives::block::HeaderDecoderError::PrevBlockhash(bitcoin_primitives::block::BlockHashDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Time(bitcoin_units::time::BlockTimeDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Version(bitcoin_primitives::block::VersionDecoderError)
+pub bitcoin_primitives::block::InvalidBlockError::InvalidCoinbase
+pub bitcoin_primitives::block::InvalidBlockError::InvalidMerkleRoot
+pub bitcoin_primitives::block::InvalidBlockError::InvalidWitnessCommitment
+pub bitcoin_primitives::block::InvalidBlockError::NoTransactions
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub bitcoin_primitives::transaction::ParseOutPointError::Format
+pub bitcoin_primitives::transaction::ParseOutPointError::TooLong
+pub bitcoin_primitives::transaction::ParseOutPointError::Txid(hex_conservative::error::DecodeFixedLengthBytesError)
+pub bitcoin_primitives::transaction::ParseOutPointError::Vout(bitcoin_units::parse_int::ParseIntError)
+pub bitcoin_primitives::transaction::ParseOutPointError::VoutNotCanonical
+pub bitcoin_primitives::transaction::Transaction::inputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_units::locktime::absolute::LockTime
+pub bitcoin_primitives::transaction::Transaction::outputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptSigBuf
+pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_units::sequence::Sequence
+pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::transaction::TxOut::amount: bitcoin_units::amount::unsigned::encapsulate::Amount
+pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptPubKeyBuf
+pub const bitcoin_primitives::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
+pub const bitcoin_primitives::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::WitnessCommitment::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::encapsulate::Weight
+pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: Self
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const fn bitcoin_primitives::BlockHash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::BlockHash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::BlockHash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Ntxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Ntxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Ntxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::TxMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Txid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Txid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Txid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessCommitment::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Wtxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Wtxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Wtxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::block::BlockHashDecoder::new() -> Self
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub const fn bitcoin_primitives::block::VersionDecoder::new() -> Self
+pub const fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub const fn bitcoin_primitives::pow::CompactTargetDecoder::new() -> Self
+pub const fn bitcoin_primitives::script::Script<T>::as_bytes(&self) -> &[u8]
+pub const fn bitcoin_primitives::script::Script<T>::from_bytes(bytes: &[u8]) -> &Self
+pub const fn bitcoin_primitives::script::Script<T>::is_empty(&self) -> bool
+pub const fn bitcoin_primitives::script::Script<T>::len(&self) -> usize
+pub const fn bitcoin_primitives::script::Script<T>::new() -> &'static Self
+pub const fn bitcoin_primitives::script::ScriptBuf<T>::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
+pub const fn bitcoin_primitives::script::ScriptBuf<T>::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptBufDecoder<T>::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::transaction::OutPointDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::TransactionDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::Version::is_standard(self) -> bool
+pub const fn bitcoin_primitives::transaction::Version::maybe_non_standard(version: u32) -> Self
+pub const fn bitcoin_primitives::transaction::Version::to_u32(self) -> u32
+pub const fn bitcoin_primitives::transaction::VersionDecoder::new() -> Self
+pub const fn bitcoin_primitives::witness::Witness::len(&self) -> usize
+pub const fn bitcoin_primitives::witness::Witness::new() -> Self
+pub const fn bitcoin_primitives::witness::WitnessDecoder::new() -> Self
+pub enum bitcoin_primitives::BlockChecked
+pub enum bitcoin_primitives::BlockUnchecked
+pub enum bitcoin_primitives::block::Checked
+pub enum bitcoin_primitives::block::Unchecked
+pub enum bitcoin_primitives::script::RedeemScriptTag
+pub enum bitcoin_primitives::script::ScriptPubKeyTag
+pub enum bitcoin_primitives::script::ScriptSigTag
+pub enum bitcoin_primitives::script::TapScriptTag
+pub enum bitcoin_primitives::script::WitnessScriptTag
+pub extern crate bitcoin_primitives::hex
+pub fn &'a bitcoin_primitives::script::Script<T>::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
+pub fn &'de bitcoin_primitives::script::Script<T>::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn &[T; N]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn &[T]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn &bitcoin_primitives::script::Script<T>::default() -> Self
+pub fn [T; N]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn [T]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script<T>>::from(value: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::boxed::Box<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(v: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>) -> Self
+pub fn alloc::rc::Rc<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::rc::Rc<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::sync::Arc<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::sync::Arc<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::vec::Vec<T>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn bitcoin_primitives::BlockHash::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::clone(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::BlockHash::cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::BlockHash::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::BlockHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::BlockHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::BlockHash::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::BlockHash::eq(&self, other: &bitcoin_primitives::BlockHash) -> bool
+pub fn bitcoin_primitives::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::BlockHash::from(block: &bitcoin_primitives::block::Block) -> Self
+pub fn bitcoin_primitives::BlockHash::from(block: bitcoin_primitives::block::Block) -> Self
+pub fn bitcoin_primitives::BlockHash::from(header: &bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::from(header: bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::BlockHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::Ntxid::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::clone(&self) -> bitcoin_primitives::Ntxid
+pub fn bitcoin_primitives::Ntxid::cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Ntxid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::Ntxid, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::Ntxid::eq(&self, other: &bitcoin_primitives::Ntxid) -> bool
+pub fn bitcoin_primitives::Ntxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Ntxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::Ntxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Ntxid::partial_cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Ntxid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::TxMerkleNode::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Txid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::TxMerkleNode::clone(&self) -> bitcoin_primitives::TxMerkleNode
+pub fn bitcoin_primitives::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::TxMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::TxMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::TxMerkleNode, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::TxMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::TxMerkleNode::eq(&self, other: &bitcoin_primitives::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::TxMerkleNode::from_leaf(leaf: bitcoin_primitives::Txid) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::TxMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::Txid::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::clone(&self) -> bitcoin_primitives::Txid
+pub fn bitcoin_primitives::Txid::cmp(&self, other: &bitcoin_primitives::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Txid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::Txid, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::Txid::eq(&self, other: &bitcoin_primitives::Txid) -> bool
+pub fn bitcoin_primitives::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Txid::partial_cmp(&self, other: &bitcoin_primitives::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Txid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::WitnessCommitment::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::clone(&self) -> bitcoin_primitives::WitnessCommitment
+pub fn bitcoin_primitives::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessCommitment::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::WitnessCommitment, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::WitnessCommitment::eq(&self, other: &bitcoin_primitives::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessCommitment::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::WitnessMerkleNode::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Wtxid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::WitnessMerkleNode
+pub fn bitcoin_primitives::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::WitnessMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::WitnessMerkleNode, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::WitnessMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessMerkleNode::from_leaf(leaf: bitcoin_primitives::Wtxid) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::Wtxid::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::clone(&self) -> bitcoin_primitives::Wtxid
+pub fn bitcoin_primitives::Wtxid::cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Wtxid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::Wtxid, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::Wtxid::eq(&self, other: &bitcoin_primitives::Wtxid) -> bool
+pub fn bitcoin_primitives::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Wtxid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::block::Block::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Block::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Block::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
+pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
+pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::WitnessMerkleNode>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::check_merkle_root(&self) -> bool
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::check_witness_commitment(&self) -> (bool, core::option::Option<bitcoin_primitives::WitnessMerkleNode>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::compute_witness_commitment(&self, witness_reserved_value: &[u8]) -> core::option::Option<(bitcoin_primitives::WitnessMerkleNode, bitcoin_primitives::WitnessCommitment)>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> Self
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::validate(self) -> core::result::Result<bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>, bitcoin_primitives::block::InvalidBlockError>
+pub fn bitcoin_primitives::block::BlockDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::BlockDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::BlockDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::BlockDecoderError::clone(&self) -> bitcoin_primitives::block::BlockDecoderError
+pub fn bitcoin_primitives::block::BlockDecoderError::eq(&self, other: &bitcoin_primitives::block::BlockDecoderError) -> bool
+pub fn bitcoin_primitives::block::BlockDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::BlockDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::block::BlockEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::BlockEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHashDecoder::default() -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::BlockHashDecoderError::clone(&self) -> bitcoin_primitives::block::BlockHashDecoderError
+pub fn bitcoin_primitives::block::BlockHashDecoderError::eq(&self, other: &bitcoin_primitives::block::BlockHashDecoderError) -> bool
+pub fn bitcoin_primitives::block::BlockHashDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::block::BlockHashEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::BlockHashEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
+pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
+pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Header::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Header::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::HeaderDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::HeaderDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::HeaderDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::HeaderDecoderError::clone(&self) -> bitcoin_primitives::block::HeaderDecoderError
+pub fn bitcoin_primitives::block::HeaderDecoderError::eq(&self, other: &bitcoin_primitives::block::HeaderDecoderError) -> bool
+pub fn bitcoin_primitives::block::HeaderDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::HeaderDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::HeaderDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::block::HeaderEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::HeaderEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::InvalidBlockError::clone(&self) -> bitcoin_primitives::block::InvalidBlockError
+pub fn bitcoin_primitives::block::InvalidBlockError::eq(&self, other: &bitcoin_primitives::block::InvalidBlockError) -> bool
+pub fn bitcoin_primitives::block::InvalidBlockError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::InvalidBlockError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
+pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
+pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Version::default() -> Self
+pub fn bitcoin_primitives::block::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::block::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::block::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::block::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::VersionDecoderError::clone(&self) -> bitcoin_primitives::block::VersionDecoderError
+pub fn bitcoin_primitives::block::VersionDecoderError::eq(&self, other: &bitcoin_primitives::block::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::block::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::VersionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::VersionDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::block::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::compute_merkle_root(transactions: &[bitcoin_primitives::transaction::Transaction]) -> core::option::Option<bitcoin_primitives::TxMerkleNode>
+pub fn bitcoin_primitives::block::compute_witness_root(transactions: &[bitcoin_primitives::transaction::Transaction]) -> core::option::Option<bitcoin_primitives::WitnessMerkleNode>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::pow::CompactTarget::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::pow::CompactTarget::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTarget::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::pow::CompactTarget::to_hex(self) -> alloc::string::String
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::default() -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::clone(&self) -> bitcoin_primitives::pow::CompactTargetDecoderError
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::eq(&self, other: &bitcoin_primitives::pow::CompactTargetDecoderError) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::invalid_size(&self) -> usize
+pub fn bitcoin_primitives::script::RedeemScriptTag::clone(&self) -> bitcoin_primitives::script::RedeemScriptTag
+pub fn bitcoin_primitives::script::RedeemScriptTag::cmp(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::RedeemScriptTag::eq(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::RedeemScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::as_mut(&mut self) -> &mut Self
+pub fn bitcoin_primitives::script::Script<T>::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script<T>::as_mut_bytes(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script<T>::as_ref(&self) -> &Self
+pub fn bitcoin_primitives::script::Script<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script<T>::cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::Script<T>::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::script::Script<T>::eq(&self, other: &bitcoin_primitives::script::Script<T>) -> bool
+pub fn bitcoin_primitives::script::Script<T>::eq(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> bool
+pub fn bitcoin_primitives::script::Script<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::Script<T>::from_bytes_mut(bytes: &mut [u8]) -> &mut Self
+pub fn bitcoin_primitives::script::Script<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf<T>
+pub fn bitcoin_primitives::script::Script<T>::partial_cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::script::Script<T>::to_bytes(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::Script<T>::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::Script<T>::to_owned(&self) -> Self::Owned
+pub fn bitcoin_primitives::script::Script<T>::to_vec(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_ref(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_script(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::borrow(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::capacity(&self) -> usize
+pub fn bitcoin_primitives::script::ScriptBuf<T>::clone(&self) -> bitcoin_primitives::script::ScriptBuf<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptBuf<T>::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::script::ScriptBuf<T>::default() -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::deref(&self) -> &Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf<T>::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf<T>::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::eq(&self, other: &bitcoin_primitives::script::Script<T>) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf<T>::eq(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(v: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::into_bytes(self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::partial_cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::reserve(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::reserve_exact(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::script::ScriptBuf<T>::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::ScriptBuf<T>::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::default() -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::read_limit(&self) -> usize
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::clone(&self) -> bitcoin_primitives::script::ScriptBufDecoderError
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::eq(&self, other: &bitcoin_primitives::script::ScriptBufDecoderError) -> bool
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::ByteVecDecoderError) -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::script::ScriptEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::script::ScriptEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::ScriptHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
+pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptHash::from_script<T>(redeem_script: &bitcoin_primitives::script::Script<T>) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError> where T: bitcoin_primitives::script::ScriptHashableTag
+pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked<T>(script: &bitcoin_primitives::script::Script<T>) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::clone(&self) -> bitcoin_primitives::script::ScriptPubKeyTag
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::cmp(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::eq(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> bool
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptSigTag::clone(&self) -> bitcoin_primitives::script::ScriptSigTag
+pub fn bitcoin_primitives::script::ScriptSigTag::cmp(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptSigTag::eq(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> bool
+pub fn bitcoin_primitives::script::ScriptSigTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptSigTag::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::TapScriptTag::clone(&self) -> bitcoin_primitives::script::TapScriptTag
+pub fn bitcoin_primitives::script::TapScriptTag::cmp(&self, other: &bitcoin_primitives::script::TapScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::TapScriptTag::eq(&self, other: &bitcoin_primitives::script::TapScriptTag) -> bool
+pub fn bitcoin_primitives::script::TapScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::TapScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::TapScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::WScriptHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
+pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::WitnessScript) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
+pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::WitnessScript) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::WitnessScript) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::WitnessScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::WitnessScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::invalid_size(&self) -> usize
+pub fn bitcoin_primitives::script::WitnessScriptTag::clone(&self) -> bitcoin_primitives::script::WitnessScriptTag
+pub fn bitcoin_primitives::script::WitnessScriptTag::cmp(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WitnessScriptTag::eq(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WitnessScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::OutPoint::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::OutPoint::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::OutPointDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::OutPointDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::clone(&self) -> bitcoin_primitives::transaction::OutPointDecoderError
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::eq(&self, other: &bitcoin_primitives::transaction::OutPointDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::ParseOutPointError::clone(&self) -> bitcoin_primitives::transaction::ParseOutPointError
+pub fn bitcoin_primitives::transaction::ParseOutPointError::eq(&self, other: &bitcoin_primitives::transaction::ParseOutPointError) -> bool
+pub fn bitcoin_primitives::transaction::ParseOutPointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::ParseOutPointError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::ParseOutPointError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::Transaction::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
+pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_primitives::Ntxid
+pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::Txid
+pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::Wtxid
+pub fn bitcoin_primitives::transaction::Transaction::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::Transaction::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Transaction::is_coinbase(&self) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::clone(&self) -> bitcoin_primitives::transaction::TransactionDecoderError
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TransactionDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxInDecoderError>) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxOutDecoderError>) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_primitives::transaction::VersionDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_primitives::witness::WitnessDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_units::locktime::absolute::error::LockTimeDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::TransactionEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TransactionEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::TxIn::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
+pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxIn::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::TxIn::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
+pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxInDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxInDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxInDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxInDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxInDecoderError
+pub fn bitcoin_primitives::transaction::TxInDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxInDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxInDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxInDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxInDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::TxInEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TxInEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxMerkleNodeDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::TxOut::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
+pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxOut::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::TxOut::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
+pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxOutDecoderError
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxOutDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::TxOutEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TxOutEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::VersionDecoderError::clone(&self) -> bitcoin_primitives::transaction::VersionDecoderError
+pub fn bitcoin_primitives::transaction::VersionDecoderError::eq(&self, other: &bitcoin_primitives::transaction::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::VersionDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'e>::new(inputs: &'e [bitcoin_primitives::transaction::TxIn]) -> Self
+pub fn bitcoin_primitives::witness::Iter<'a>::clone(&self) -> bitcoin_primitives::witness::Iter<'a>
+pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn bitcoin_primitives::witness::UnexpectedEofError::clone(&self) -> bitcoin_primitives::witness::UnexpectedEofError
+pub fn bitcoin_primitives::witness::UnexpectedEofError::eq(&self, other: &bitcoin_primitives::witness::UnexpectedEofError) -> bool
+pub fn bitcoin_primitives::witness::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::Witness::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
+pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
+pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
+pub fn bitcoin_primitives::witness::Witness::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::witness::Witness::default() -> Self
+pub fn bitcoin_primitives::witness::Witness::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::witness::Witness::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &&[T; N]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &&[T]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &[T; N]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &[T]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::boxed::Box<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::rc::Rc<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::sync::Arc<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::vec::Vec<T>) -> bool
+pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::Witness::from(arr: &[&[u8]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(arr: [&[u8]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8; N]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[[u8; N]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: [&[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: [[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_hex<I, T>(iter: I) -> core::result::Result<Self, hex_conservative::error::DecodeVariableLengthBytesError> where I: core::iter::traits::collect::IntoIterator<Item = T>, T: core::convert::AsRef<str>
+pub fn bitcoin_primitives::witness::Witness::from_iter<I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
+pub fn bitcoin_primitives::witness::Witness::get(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::get_back(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
+pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
+pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
+pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
+pub fn bitcoin_primitives::witness::Witness::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
+pub fn bitcoin_primitives::witness::WitnessDecoder::default() -> Self
+pub fn bitcoin_primitives::witness::WitnessDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::witness::WitnessDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::witness::WitnessDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::witness::WitnessDecoderError::clone(&self) -> bitcoin_primitives::witness::WitnessDecoderError
+pub fn bitcoin_primitives::witness::WitnessDecoderError::eq(&self, other: &bitcoin_primitives::witness::WitnessDecoderError) -> bool
+pub fn bitcoin_primitives::witness::WitnessDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::WitnessDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::witness::WitnessDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::witness::WitnessEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::witness::WitnessEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn u32::from(version: bitcoin_primitives::transaction::Version) -> Self
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::script
+pub mod bitcoin_primitives::transaction
+pub mod bitcoin_primitives::witness
+pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::BlockVersion(_)
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Ntxid(_)
+pub struct bitcoin_primitives::OutPoint
+pub struct bitcoin_primitives::Transaction
+pub struct bitcoin_primitives::TransactionVersion(_)
+pub struct bitcoin_primitives::TxIn
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::TxOut
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::Witness
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::block::BlockDecoder(_)
+pub struct bitcoin_primitives::block::BlockDecoderError(_)
+pub struct bitcoin_primitives::block::BlockEncoder<'e>(_)
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::BlockHashDecoder(_)
+pub struct bitcoin_primitives::block::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::block::BlockHashEncoder(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::HeaderDecoder(_)
+pub struct bitcoin_primitives::block::HeaderEncoder(_)
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::VersionDecoder(_)
+pub struct bitcoin_primitives::block::VersionDecoderError(_)
+pub struct bitcoin_primitives::block::VersionEncoder(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoder(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoderError(_)
+pub struct bitcoin_primitives::pow::CompactTargetEncoder(_)
+pub struct bitcoin_primitives::script::RedeemScriptSizeError
+pub struct bitcoin_primitives::script::ScriptBuf<T>(_, _)
+pub struct bitcoin_primitives::script::ScriptBufDecoder<T>(_, _)
+pub struct bitcoin_primitives::script::ScriptBufDecoderError(_)
+pub struct bitcoin_primitives::script::ScriptEncoder<'e>(_)
+pub struct bitcoin_primitives::script::ScriptHash(_)
+pub struct bitcoin_primitives::script::WScriptHash(_)
+pub struct bitcoin_primitives::script::WitnessScriptSizeError
+pub struct bitcoin_primitives::transaction::BlockHashDecoder(_)
+pub struct bitcoin_primitives::transaction::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::transaction::Ntxid(_)
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::OutPointDecoder(_)
+pub struct bitcoin_primitives::transaction::OutPointDecoderError(_)
+pub struct bitcoin_primitives::transaction::OutPointEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::Transaction
+pub struct bitcoin_primitives::transaction::TransactionDecoder
+pub struct bitcoin_primitives::transaction::TransactionDecoderError(_)
+pub struct bitcoin_primitives::transaction::TransactionEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::TxIn
+pub struct bitcoin_primitives::transaction::TxInDecoder(_)
+pub struct bitcoin_primitives::transaction::TxInDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxInEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoder(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxOut
+pub struct bitcoin_primitives::transaction::TxOutDecoder(_)
+pub struct bitcoin_primitives::transaction::TxOutDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxOutEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(_)
+pub struct bitcoin_primitives::transaction::VersionDecoder(_)
+pub struct bitcoin_primitives::transaction::VersionDecoderError(_)
+pub struct bitcoin_primitives::transaction::VersionEncoder(_)
+pub struct bitcoin_primitives::transaction::WitnessesEncoder<'e>
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub struct bitcoin_primitives::witness::Iter<'a>
+pub struct bitcoin_primitives::witness::UnexpectedEofError
+pub struct bitcoin_primitives::witness::Witness
+pub struct bitcoin_primitives::witness::WitnessDecoder
+pub struct bitcoin_primitives::witness::WitnessDecoderError(_)
+pub struct bitcoin_primitives::witness::WitnessEncoder<'a>(_)
+pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::script::ScriptHashableTag: bitcoin_primitives::script::sealed::Sealed
+pub trait bitcoin_primitives::script::Tag
+pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
+pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
+pub type bitcoin_primitives::BlockHash::Decoder = bitcoin_primitives::block::BlockHashDecoder
+pub type bitcoin_primitives::BlockHash::Encoder<'e> = bitcoin_primitives::block::BlockHashEncoder
+pub type bitcoin_primitives::BlockHash::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::Ntxid::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::RedeemScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::RedeemScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::ScriptPubKey = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::ScriptPubKeyBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::ScriptSig = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::ScriptSigBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::TapScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::TapScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::TxMerkleNode::Decoder = bitcoin_primitives::transaction::TxMerkleNodeDecoder
+pub type bitcoin_primitives::TxMerkleNode::Encoder<'e> = bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+pub type bitcoin_primitives::TxMerkleNode::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::Txid::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::WitnessCommitment::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::WitnessMerkleNode::Decoder = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeDecoder
+pub type bitcoin_primitives::WitnessMerkleNode::Encoder<'e> = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeEncoder
+pub type bitcoin_primitives::WitnessMerkleNode::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::WitnessScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::WitnessScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::Wtxid::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::block::Block::Decoder = bitcoin_primitives::block::BlockDecoder
+pub type bitcoin_primitives::block::Block::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_primitives::block::HeaderEncoder, bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_consensus_encoding::encode::encoders::CompactSizeEncoder, bitcoin_consensus_encoding::encode::encoders::SliceEncoder<'e, bitcoin_primitives::transaction::Transaction>>>
+pub type bitcoin_primitives::block::BlockDecoder::Error = bitcoin_primitives::block::BlockDecoderError
+pub type bitcoin_primitives::block::BlockDecoder::Output = bitcoin_primitives::block::Block
+pub type bitcoin_primitives::block::BlockHashDecoder::Error = bitcoin_primitives::block::BlockHashDecoderError
+pub type bitcoin_primitives::block::BlockHashDecoder::Output = bitcoin_primitives::BlockHash
+pub type bitcoin_primitives::block::Header::Decoder = bitcoin_primitives::block::HeaderDecoder
+pub type bitcoin_primitives::block::Header::Encoder<'e> = bitcoin_primitives::block::HeaderEncoder
+pub type bitcoin_primitives::block::HeaderDecoder::Error = bitcoin_primitives::block::HeaderDecoderError
+pub type bitcoin_primitives::block::HeaderDecoder::Output = bitcoin_primitives::block::Header
+pub type bitcoin_primitives::block::Version::Decoder = bitcoin_primitives::block::VersionDecoder
+pub type bitcoin_primitives::block::Version::Encoder<'e> = bitcoin_primitives::block::VersionEncoder
+pub type bitcoin_primitives::block::VersionDecoder::Error = bitcoin_primitives::block::VersionDecoderError
+pub type bitcoin_primitives::block::VersionDecoder::Output = bitcoin_primitives::block::Version
+pub type bitcoin_primitives::pow::CompactTarget::Decoder = bitcoin_primitives::pow::CompactTargetDecoder
+pub type bitcoin_primitives::pow::CompactTarget::Encoder<'e> = bitcoin_primitives::pow::CompactTargetEncoder
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Error = bitcoin_primitives::pow::CompactTargetDecoderError
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Output = bitcoin_primitives::pow::CompactTarget
+pub type bitcoin_primitives::script::RedeemScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::script::RedeemScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::script::Script<T>::Encoder<'a> where Self: 'a = bitcoin_primitives::script::ScriptEncoder<'a>
+pub type bitcoin_primitives::script::Script<T>::Output = bitcoin_primitives::script::Script<T>
+pub type bitcoin_primitives::script::Script<T>::Owned = bitcoin_primitives::script::ScriptBuf<T>
+pub type bitcoin_primitives::script::ScriptBuf<T>::Decoder = bitcoin_primitives::script::ScriptBufDecoder<T>
+pub type bitcoin_primitives::script::ScriptBuf<T>::Target = bitcoin_primitives::script::Script<T>
+pub type bitcoin_primitives::script::ScriptBufDecoder<T>::Error = bitcoin_primitives::script::ScriptBufDecoderError
+pub type bitcoin_primitives::script::ScriptBufDecoder<T>::Output = bitcoin_primitives::script::ScriptBuf<T>
+pub type bitcoin_primitives::script::ScriptHash::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
+pub type bitcoin_primitives::script::ScriptPubKey = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptPubKeyBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptPubKeyBufDecoder = bitcoin_primitives::script::ScriptBufDecoder<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptSig = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::ScriptSigBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::ScriptSigBufDecoder = bitcoin_primitives::script::ScriptBufDecoder<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::TapScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::script::TapScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::script::WScriptHash::Err = hex_conservative::error::DecodeFixedLengthBytesError
+pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
+pub type bitcoin_primitives::script::WitnessScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::script::WitnessScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::transaction::OutPoint::Decoder = bitcoin_primitives::transaction::OutPointDecoder
+pub type bitcoin_primitives::transaction::OutPoint::Encoder<'e> where Self: 'e = bitcoin_primitives::transaction::OutPointEncoder<'e>
+pub type bitcoin_primitives::transaction::OutPoint::Err = bitcoin_primitives::transaction::ParseOutPointError
+pub type bitcoin_primitives::transaction::OutPointDecoder::Error = bitcoin_primitives::transaction::OutPointDecoderError
+pub type bitcoin_primitives::transaction::OutPointDecoder::Output = bitcoin_primitives::transaction::OutPoint
+pub type bitcoin_primitives::transaction::Transaction::Decoder = bitcoin_primitives::transaction::TransactionDecoder
+pub type bitcoin_primitives::transaction::Transaction::Encoder<'e> where Self: 'e = bitcoin_primitives::transaction::TransactionEncoder<'e>
+pub type bitcoin_primitives::transaction::TransactionDecoder::Error = bitcoin_primitives::transaction::TransactionDecoderError
+pub type bitcoin_primitives::transaction::TransactionDecoder::Output = bitcoin_primitives::transaction::Transaction
+pub type bitcoin_primitives::transaction::TxIn::Decoder = bitcoin_primitives::transaction::TxInDecoder
+pub type bitcoin_primitives::transaction::TxIn::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder3<bitcoin_primitives::transaction::OutPointEncoder<'e>, bitcoin_primitives::script::ScriptEncoder<'e>, bitcoin_units::sequence::SequenceEncoder>
+pub type bitcoin_primitives::transaction::TxInDecoder::Error = bitcoin_primitives::transaction::TxInDecoderError
+pub type bitcoin_primitives::transaction::TxInDecoder::Output = bitcoin_primitives::transaction::TxIn
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Error = bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Output = bitcoin_primitives::TxMerkleNode
+pub type bitcoin_primitives::transaction::TxOut::Decoder = bitcoin_primitives::transaction::TxOutDecoder
+pub type bitcoin_primitives::transaction::TxOut::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_units::amount::unsigned::AmountEncoder, bitcoin_primitives::script::ScriptEncoder<'e>>
+pub type bitcoin_primitives::transaction::TxOutDecoder::Error = bitcoin_primitives::transaction::TxOutDecoderError
+pub type bitcoin_primitives::transaction::TxOutDecoder::Output = bitcoin_primitives::transaction::TxOut
+pub type bitcoin_primitives::transaction::Version::Decoder = bitcoin_primitives::transaction::VersionDecoder
+pub type bitcoin_primitives::transaction::Version::Encoder<'e> = bitcoin_primitives::transaction::VersionEncoder
+pub type bitcoin_primitives::transaction::VersionDecoder::Error = bitcoin_primitives::transaction::VersionDecoderError
+pub type bitcoin_primitives::transaction::VersionDecoder::Output = bitcoin_primitives::transaction::Version
+pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
+pub type bitcoin_primitives::witness::Witness::Decoder = bitcoin_primitives::witness::WitnessDecoder
+pub type bitcoin_primitives::witness::Witness::Encoder<'a> where Self: 'a = bitcoin_primitives::witness::WitnessEncoder<'a>
+pub type bitcoin_primitives::witness::Witness::Output = [u8]
+pub type bitcoin_primitives::witness::WitnessDecoder::Error = bitcoin_primitives::witness::WitnessDecoderError
+pub type bitcoin_primitives::witness::WitnessDecoder::Output = bitcoin_primitives::witness::Witness
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockHeightInterval
+pub use bitcoin_primitives::BlockMtp
+pub use bitcoin_primitives::BlockMtpInterval
+pub use bitcoin_primitives::BlockTime
+pub use bitcoin_primitives::BlockTimeDecoder
+pub use bitcoin_primitives::BlockTimeDecoderError
+pub use bitcoin_primitives::FeeRate
+pub use bitcoin_primitives::NumOpResult
+pub use bitcoin_primitives::Sequence
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute
+pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::block::BlockHeight
+pub use bitcoin_primitives::block::BlockHeightDecoder
+pub use bitcoin_primitives::block::BlockHeightDecoderError
+pub use bitcoin_primitives::block::BlockHeightEncoder
+pub use bitcoin_primitives::block::BlockHeightInterval
+pub use bitcoin_primitives::block::BlockMtp
+pub use bitcoin_primitives::block::BlockMtpInterval
+pub use bitcoin_primitives::block::TooBigForRelativeHeightError
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime
+pub use bitcoin_primitives::parse_int
+pub use bitcoin_primitives::relative
+pub use bitcoin_primitives::result
+pub use bitcoin_primitives::sequence
+pub use bitcoin_primitives::time
+pub use bitcoin_primitives::weight
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
new file mode 100644
index 0000000000..dc3dc482c1
--- /dev/null
+++ b/api/primitives/alloc-only.txt
@@ -0,0 +1,1890 @@
+#[non_exhaustive] pub enum bitcoin_primitives::block::HeaderDecoderError
+#[non_exhaustive] pub enum bitcoin_primitives::block::InvalidBlockError
+#[repr(transparent)] pub struct bitcoin_primitives::script::Script<T>(_, _)
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Block
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Header
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::Transaction
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::TxIn
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::TxOut
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::witness::Witness
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::BlockDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::HeaderDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::VersionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TransactionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxInDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxOutDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::VersionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::witness::WitnessDecoder
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Block
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Header
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::Transaction
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::TxIn
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::TxOut
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::witness::Witness
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::BlockHashEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::HeaderEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::VersionEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::pow::CompactTargetEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::VersionEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::WitnessesEncoder<'_>
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::witness::WitnessEncoder<'_>
+impl bitcoin_primitives::BlockHash
+impl bitcoin_primitives::Ntxid
+impl bitcoin_primitives::TxMerkleNode
+impl bitcoin_primitives::Txid
+impl bitcoin_primitives::WitnessCommitment
+impl bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_primitives::Wtxid
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+impl bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::VersionDecoder
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_primitives::script::RedeemScriptSizeError
+impl bitcoin_primitives::script::ScriptHash
+impl bitcoin_primitives::script::ScriptHashableTag for bitcoin_primitives::script::RedeemScriptTag
+impl bitcoin_primitives::script::ScriptHashableTag for bitcoin_primitives::script::ScriptPubKeyTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::RedeemScriptTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::ScriptPubKeyTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::ScriptSigTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::TapScriptTag
+impl bitcoin_primitives::script::Tag for bitcoin_primitives::script::WitnessScriptTag
+impl bitcoin_primitives::script::WScriptHash
+impl bitcoin_primitives::script::WitnessScriptSizeError
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_primitives::transaction::Transaction
+impl bitcoin_primitives::transaction::TransactionDecoder
+impl bitcoin_primitives::transaction::TxIn
+impl bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::VersionDecoder
+impl bitcoin_primitives::witness::Witness
+impl bitcoin_primitives::witness::WitnessDecoder
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::BlockHash
+impl core::clone::Clone for bitcoin_primitives::Ntxid
+impl core::clone::Clone for bitcoin_primitives::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Txid
+impl core::clone::Clone for bitcoin_primitives::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Wtxid
+impl core::clone::Clone for bitcoin_primitives::block::BlockDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::BlockHashDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::Checked
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::HeaderDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::InvalidBlockError
+impl core::clone::Clone for bitcoin_primitives::block::Unchecked
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::VersionDecoderError
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptTag
+impl core::clone::Clone for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::clone::Clone for bitcoin_primitives::script::ScriptSigTag
+impl core::clone::Clone for bitcoin_primitives::script::TapScriptTag
+impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptTag
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
+impl core::clone::Clone for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
+impl core::clone::Clone for bitcoin_primitives::transaction::TxInDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::VersionDecoderError
+impl core::clone::Clone for bitcoin_primitives::witness::UnexpectedEofError
+impl core::clone::Clone for bitcoin_primitives::witness::Witness
+impl core::clone::Clone for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::Eq for bitcoin_primitives::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::Ntxid
+impl core::cmp::Eq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Txid
+impl core::cmp::Eq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::block::BlockDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::Checked
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::HeaderDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::InvalidBlockError
+impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::Eq for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Eq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::cmp::Eq for bitcoin_primitives::witness::Witness
+impl core::cmp::Eq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::Ord for bitcoin_primitives::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::Ntxid
+impl core::cmp::Ord for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Txid
+impl core::cmp::Ord for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::block::Checked
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::Ord for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::Ord for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::Ntxid
+impl core::cmp::PartialEq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::HeaderDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::InvalidBlockError
+impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::cmp::PartialOrd for bitcoin_primitives::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::Ntxid
+impl core::cmp::PartialOrd for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::script::RedeemScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptSigTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::TapScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WitnessScriptTag
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
+impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
+impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::BlockHash
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Txid
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Wtxid
+impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::ByteVecDecoderError> for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxInDecoderError>> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxOutDecoderError>> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Txid
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::Wtxid
+impl core::convert::From<bitcoin_primitives::transaction::Version> for u32
+impl core::convert::From<bitcoin_primitives::transaction::VersionDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_primitives::witness::WitnessDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<bitcoin_units::locktime::absolute::error::LockTimeDecoderError> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::BlockDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::HeaderDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::InvalidBlockError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxInDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::VersionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::witness::WitnessDecoderError
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>> for bitcoin_primitives::script::WScriptHash
+impl core::default::Default for bitcoin_primitives::block::BlockHashDecoder
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::block::VersionDecoder
+impl core::default::Default for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::default::Default for bitcoin_primitives::transaction::OutPointDecoder
+impl core::default::Default for bitcoin_primitives::transaction::TransactionDecoder
+impl core::default::Default for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::default::Default for bitcoin_primitives::transaction::VersionDecoder
+impl core::default::Default for bitcoin_primitives::witness::Witness
+impl core::default::Default for bitcoin_primitives::witness::WitnessDecoder
+impl core::fmt::Debug for bitcoin_primitives::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::Ntxid
+impl core::fmt::Debug for bitcoin_primitives::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Txid
+impl core::fmt::Debug for bitcoin_primitives::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Wtxid
+impl core::fmt::Debug for bitcoin_primitives::block::BlockDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::Checked
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::HeaderDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::InvalidBlockError
+impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
+impl core::fmt::Debug for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxInDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::witness::UnexpectedEofError
+impl core::fmt::Debug for bitcoin_primitives::witness::Witness
+impl core::fmt::Debug for bitcoin_primitives::witness::WitnessDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::BlockDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::HeaderDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::InvalidBlockError
+impl core::fmt::Display for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::fmt::Display for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxInDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::witness::UnexpectedEofError
+impl core::fmt::Display for bitcoin_primitives::witness::WitnessDecoderError
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::BlockHash
+impl core::hash::Hash for bitcoin_primitives::Ntxid
+impl core::hash::Hash for bitcoin_primitives::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Txid
+impl core::hash::Hash for bitcoin_primitives::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::Checked
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Unchecked
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::script::RedeemScriptTag
+impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::hash::Hash for bitcoin_primitives::script::ScriptSigTag
+impl core::hash::Hash for bitcoin_primitives::script::TapScriptTag
+impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::WitnessScriptTag
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
+impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
+impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::hash::Hash for bitcoin_primitives::witness::Witness
+impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
+impl core::marker::Copy for bitcoin_primitives::BlockHash
+impl core::marker::Copy for bitcoin_primitives::Ntxid
+impl core::marker::Copy for bitcoin_primitives::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Txid
+impl core::marker::Copy for bitcoin_primitives::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Wtxid
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
+impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::Ntxid
+impl core::marker::Freeze for bitcoin_primitives::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Txid
+impl core::marker::Freeze for bitcoin_primitives::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::Checked
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Freeze for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
+impl core::marker::Freeze for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Freeze for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Freeze for bitcoin_primitives::witness::Witness
+impl core::marker::Freeze for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Freeze for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Send for bitcoin_primitives::BlockHash
+impl core::marker::Send for bitcoin_primitives::Ntxid
+impl core::marker::Send for bitcoin_primitives::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::Txid
+impl core::marker::Send for bitcoin_primitives::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::Wtxid
+impl core::marker::Send for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Send for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Send for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Send for bitcoin_primitives::block::Checked
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Send for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Send for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Send for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Send for bitcoin_primitives::block::Unchecked
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Send for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Send for bitcoin_primitives::script::ScriptHash
+impl core::marker::Send for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Send for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Send for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Send for bitcoin_primitives::script::WScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::Transaction
+impl core::marker::Send for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxIn
+impl core::marker::Send for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxOut
+impl core::marker::Send for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Send for bitcoin_primitives::witness::Witness
+impl core::marker::Send for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Send for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Ntxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::TapScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Sync for bitcoin_primitives::BlockHash
+impl core::marker::Sync for bitcoin_primitives::Ntxid
+impl core::marker::Sync for bitcoin_primitives::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Txid
+impl core::marker::Sync for bitcoin_primitives::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Wtxid
+impl core::marker::Sync for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Sync for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Sync for bitcoin_primitives::block::Checked
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Sync for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Sync for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Sync for bitcoin_primitives::block::Unchecked
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Sync for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Sync for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Sync for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
+impl core::marker::Sync for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
+impl core::marker::Sync for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Sync for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Sync for bitcoin_primitives::witness::Witness
+impl core::marker::Sync for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Sync for bitcoin_primitives::witness::WitnessDecoderError
+impl core::marker::Unpin for bitcoin_primitives::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::Ntxid
+impl core::marker::Unpin for bitcoin_primitives::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Txid
+impl core::marker::Unpin for bitcoin_primitives::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::block::BlockDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::BlockDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::Checked
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::InvalidBlockError
+impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptTag
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptSigTag
+impl core::marker::Unpin for bitcoin_primitives::script::TapScriptTag
+impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptTag
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
+impl core::marker::Unpin for bitcoin_primitives::transaction::TransactionDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxInDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxInDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOutDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::witness::UnexpectedEofError
+impl core::marker::Unpin for bitcoin_primitives::witness::Witness
+impl core::marker::Unpin for bitcoin_primitives::witness::WitnessDecoder
+impl core::marker::Unpin for bitcoin_primitives::witness::WitnessDecoderError
+impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::InvalidBlockError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptSigTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::TapScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::UnexpectedEofError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::InvalidBlockError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBufDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptPubKeyTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptSigTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::TapScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::UnexpectedEofError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessDecoderError
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::rc::Rc<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for alloc::sync::Arc<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<&'a bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'a, T> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<'a, T> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<'a> core::clone::Clone for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
+impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::WitnessEncoder<'a>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TransactionEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxInEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOutEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::WitnessesEncoder<'e>
+impl<T: 'static> core::default::Default for &bitcoin_primitives::script::Script<T>
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<&bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: bitcoin_primitives::script::ScriptHashableTag> core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::ScriptHash
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<&[T]> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<[T]> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::boxed::Box<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::rc::Rc<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::sync::Arc<[T]>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<alloc::vec::Vec<T>> for bitcoin_primitives::witness::Witness
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for &[T]
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for [T]
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::boxed::Box<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::rc::Rc<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::sync::Arc<[T]>
+impl<T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for alloc::vec::Vec<T>
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::Ord> core::cmp::Ord for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::Ord> core::cmp::Ord for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd for bitcoin_primitives::script::Script<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T: core::cmp::PartialOrd> core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf<T>> for bitcoin_primitives::script::Script<T>
+impl<T: core::convert::AsRef<[u8]>> core::iter::traits::collect::FromIterator<T> for bitcoin_primitives::witness::Witness
+impl<T: core::hash::Hash> core::hash::Hash for bitcoin_primitives::script::Script<T>
+impl<T: core::hash::Hash> core::hash::Hash for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> !core::marker::Sized for bitcoin_primitives::script::Script<T>
+impl<T> alloc::borrow::ToOwned for bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_primitives::script::Script<T>
+impl<T> bitcoin_primitives::script::ScriptBuf<T>
+impl<T> bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::borrow::Borrow<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::borrow::BorrowMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsMut<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::AsRef<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::Script<T>
+impl<T> core::convert::AsRef<bitcoin_primitives::script::Script<T>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script<T>>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+impl<T> core::convert::From<bitcoin_primitives::script::ScriptBuf<T>> for alloc::vec::Vec<u8>
+impl<T> core::default::Default for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::default::Default for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::fmt::Debug for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::Debug for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::fmt::Display for bitcoin_primitives::script::Script<T>
+impl<T> core::fmt::Display for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::Script<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Freeze for bitcoin_primitives::script::ScriptBufDecoder<T>
+impl<T> core::marker::Send for bitcoin_primitives::script::Script<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_primitives::script::Script<T>
+impl<T> core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::marker::Sync for bitcoin_primitives::script::Script<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_primitives::script::Script<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_primitives::script::ScriptBuf<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::marker::Unpin
+impl<T> core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf<T>
+impl<T> core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script<T>
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBufDecoder<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
+impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
+impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
+impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
+impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
+impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
+impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<&[T; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<[T; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for &[T; N]
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> core::cmp::PartialEq<bitcoin_primitives::witness::Witness> for [T; N]
+impl<const N: usize, const M: usize> core::convert::From<&[&[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<&[[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<[&[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize, const M: usize> core::convert::From<[[u8; M]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[&[u8; N]]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[&[u8]; N]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<&[[u8; N]]> for bitcoin_primitives::witness::Witness
+impl<const N: usize> core::convert::From<[&[u8]; N]> for bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::BlockHeader::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::OutPoint::vout: u32
+pub bitcoin_primitives::Transaction::inputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::Transaction::lock_time: bitcoin_units::locktime::absolute::LockTime
+pub bitcoin_primitives::Transaction::outputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptSigBuf
+pub bitcoin_primitives::TxIn::sequence: bitcoin_units::sequence::Sequence
+pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::TxOut::amount: bitcoin_units::amount::unsigned::encapsulate::Amount
+pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptPubKeyBuf
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::block::Header::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::block::HeaderDecoderError::Bits(bitcoin_primitives::pow::CompactTargetDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::MerkleRoot(bitcoin_primitives::transaction::TxMerkleNodeDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Nonce(bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError)
+pub bitcoin_primitives::block::HeaderDecoderError::PrevBlockhash(bitcoin_primitives::block::BlockHashDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Time(bitcoin_units::time::BlockTimeDecoderError)
+pub bitcoin_primitives::block::HeaderDecoderError::Version(bitcoin_primitives::block::VersionDecoderError)
+pub bitcoin_primitives::block::InvalidBlockError::InvalidCoinbase
+pub bitcoin_primitives::block::InvalidBlockError::InvalidMerkleRoot
+pub bitcoin_primitives::block::InvalidBlockError::InvalidWitnessCommitment
+pub bitcoin_primitives::block::InvalidBlockError::NoTransactions
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub bitcoin_primitives::transaction::Transaction::inputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_units::locktime::absolute::LockTime
+pub bitcoin_primitives::transaction::Transaction::outputs: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptSigBuf
+pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_units::sequence::Sequence
+pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::transaction::TxOut::amount: bitcoin_units::amount::unsigned::encapsulate::Amount
+pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptPubKeyBuf
+pub const bitcoin_primitives::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
+pub const bitcoin_primitives::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::WitnessCommitment::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::encapsulate::Weight
+pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: Self
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const fn bitcoin_primitives::BlockHash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::BlockHash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::BlockHash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Ntxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Ntxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Ntxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::TxMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Txid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Txid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Txid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessCommitment::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Wtxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Wtxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Wtxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::block::BlockHashDecoder::new() -> Self
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub const fn bitcoin_primitives::block::VersionDecoder::new() -> Self
+pub const fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub const fn bitcoin_primitives::pow::CompactTargetDecoder::new() -> Self
+pub const fn bitcoin_primitives::script::Script<T>::as_bytes(&self) -> &[u8]
+pub const fn bitcoin_primitives::script::Script<T>::from_bytes(bytes: &[u8]) -> &Self
+pub const fn bitcoin_primitives::script::Script<T>::is_empty(&self) -> bool
+pub const fn bitcoin_primitives::script::Script<T>::len(&self) -> usize
+pub const fn bitcoin_primitives::script::Script<T>::new() -> &'static Self
+pub const fn bitcoin_primitives::script::ScriptBuf<T>::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
+pub const fn bitcoin_primitives::script::ScriptBuf<T>::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptBufDecoder<T>::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::transaction::OutPointDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::TransactionDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::Version::is_standard(self) -> bool
+pub const fn bitcoin_primitives::transaction::Version::maybe_non_standard(version: u32) -> Self
+pub const fn bitcoin_primitives::transaction::Version::to_u32(self) -> u32
+pub const fn bitcoin_primitives::transaction::VersionDecoder::new() -> Self
+pub const fn bitcoin_primitives::witness::Witness::len(&self) -> usize
+pub const fn bitcoin_primitives::witness::Witness::new() -> Self
+pub const fn bitcoin_primitives::witness::WitnessDecoder::new() -> Self
+pub enum bitcoin_primitives::BlockChecked
+pub enum bitcoin_primitives::BlockUnchecked
+pub enum bitcoin_primitives::block::Checked
+pub enum bitcoin_primitives::block::Unchecked
+pub enum bitcoin_primitives::script::RedeemScriptTag
+pub enum bitcoin_primitives::script::ScriptPubKeyTag
+pub enum bitcoin_primitives::script::ScriptSigTag
+pub enum bitcoin_primitives::script::TapScriptTag
+pub enum bitcoin_primitives::script::WitnessScriptTag
+pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
+pub fn &[T; N]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn &[T]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn &bitcoin_primitives::script::Script<T>::default() -> Self
+pub fn [T; N]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn [T]::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script<T>>::from(value: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::boxed::Box<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(v: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script<T>>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>) -> Self
+pub fn alloc::rc::Rc<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::rc::Rc<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::sync::Arc<[T]>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::sync::Arc<bitcoin_primitives::script::Script<T>>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn alloc::vec::Vec<T>::eq(&self, rhs: &bitcoin_primitives::witness::Witness) -> bool
+pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf<T>) -> Self
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::clone(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::BlockHash::cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::BlockHash::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::BlockHash::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::BlockHash::eq(&self, other: &bitcoin_primitives::BlockHash) -> bool
+pub fn bitcoin_primitives::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::BlockHash::from(block: &bitcoin_primitives::block::Block) -> Self
+pub fn bitcoin_primitives::BlockHash::from(block: bitcoin_primitives::block::Block) -> Self
+pub fn bitcoin_primitives::BlockHash::from(header: &bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::from(header: bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::clone(&self) -> bitcoin_primitives::Ntxid
+pub fn bitcoin_primitives::Ntxid::cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Ntxid::eq(&self, other: &bitcoin_primitives::Ntxid) -> bool
+pub fn bitcoin_primitives::Ntxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Ntxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Ntxid::partial_cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Txid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::TxMerkleNode::clone(&self) -> bitcoin_primitives::TxMerkleNode
+pub fn bitcoin_primitives::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::TxMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::TxMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::TxMerkleNode::eq(&self, other: &bitcoin_primitives::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::TxMerkleNode::from_leaf(leaf: bitcoin_primitives::Txid) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::clone(&self) -> bitcoin_primitives::Txid
+pub fn bitcoin_primitives::Txid::cmp(&self, other: &bitcoin_primitives::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Txid::eq(&self, other: &bitcoin_primitives::Txid) -> bool
+pub fn bitcoin_primitives::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Txid::partial_cmp(&self, other: &bitcoin_primitives::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::clone(&self) -> bitcoin_primitives::WitnessCommitment
+pub fn bitcoin_primitives::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessCommitment::eq(&self, other: &bitcoin_primitives::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Wtxid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::WitnessMerkleNode
+pub fn bitcoin_primitives::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::WitnessMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessMerkleNode::from_leaf(leaf: bitcoin_primitives::Wtxid) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::clone(&self) -> bitcoin_primitives::Wtxid
+pub fn bitcoin_primitives::Wtxid::cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Wtxid::eq(&self, other: &bitcoin_primitives::Wtxid) -> bool
+pub fn bitcoin_primitives::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> Self
+pub fn bitcoin_primitives::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Block::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Block::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
+pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
+pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::WitnessMerkleNode>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::check_merkle_root(&self) -> bool
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::check_witness_commitment(&self) -> (bool, core::option::Option<bitcoin_primitives::WitnessMerkleNode>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::compute_witness_commitment(&self, witness_reserved_value: &[u8]) -> core::option::Option<(bitcoin_primitives::WitnessMerkleNode, bitcoin_primitives::WitnessCommitment)>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> Self
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::validate(self) -> core::result::Result<bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>, bitcoin_primitives::block::InvalidBlockError>
+pub fn bitcoin_primitives::block::BlockDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::BlockDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::BlockDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::BlockDecoderError::clone(&self) -> bitcoin_primitives::block::BlockDecoderError
+pub fn bitcoin_primitives::block::BlockDecoderError::eq(&self, other: &bitcoin_primitives::block::BlockDecoderError) -> bool
+pub fn bitcoin_primitives::block::BlockDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::BlockEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::BlockEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHashDecoder::default() -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::BlockHashDecoderError::clone(&self) -> bitcoin_primitives::block::BlockHashDecoderError
+pub fn bitcoin_primitives::block::BlockHashDecoderError::eq(&self, other: &bitcoin_primitives::block::BlockHashDecoderError) -> bool
+pub fn bitcoin_primitives::block::BlockHashDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::BlockHashEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::BlockHashEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
+pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
+pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Header::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::HeaderDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::HeaderDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::HeaderDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::HeaderDecoderError::clone(&self) -> bitcoin_primitives::block::HeaderDecoderError
+pub fn bitcoin_primitives::block::HeaderDecoderError::eq(&self, other: &bitcoin_primitives::block::HeaderDecoderError) -> bool
+pub fn bitcoin_primitives::block::HeaderDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::HeaderDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::HeaderEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::HeaderEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::InvalidBlockError::clone(&self) -> bitcoin_primitives::block::InvalidBlockError
+pub fn bitcoin_primitives::block::InvalidBlockError::eq(&self, other: &bitcoin_primitives::block::InvalidBlockError) -> bool
+pub fn bitcoin_primitives::block::InvalidBlockError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::InvalidBlockError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
+pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
+pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Version::default() -> Self
+pub fn bitcoin_primitives::block::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::block::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::VersionDecoderError::clone(&self) -> bitcoin_primitives::block::VersionDecoderError
+pub fn bitcoin_primitives::block::VersionDecoderError::eq(&self, other: &bitcoin_primitives::block::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::block::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::VersionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::compute_merkle_root(transactions: &[bitcoin_primitives::transaction::Transaction]) -> core::option::Option<bitcoin_primitives::TxMerkleNode>
+pub fn bitcoin_primitives::block::compute_witness_root(transactions: &[bitcoin_primitives::transaction::Transaction]) -> core::option::Option<bitcoin_primitives::WitnessMerkleNode>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::pow::CompactTarget::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTarget::to_hex(self) -> alloc::string::String
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::default() -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::clone(&self) -> bitcoin_primitives::pow::CompactTargetDecoderError
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::eq(&self, other: &bitcoin_primitives::pow::CompactTargetDecoderError) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::invalid_size(&self) -> usize
+pub fn bitcoin_primitives::script::RedeemScriptTag::clone(&self) -> bitcoin_primitives::script::RedeemScriptTag
+pub fn bitcoin_primitives::script::RedeemScriptTag::cmp(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::RedeemScriptTag::eq(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::RedeemScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::RedeemScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::as_mut(&mut self) -> &mut Self
+pub fn bitcoin_primitives::script::Script<T>::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script<T>::as_mut_bytes(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script<T>::as_ref(&self) -> &Self
+pub fn bitcoin_primitives::script::Script<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script<T>::cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::Script<T>::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::script::Script<T>::eq(&self, other: &bitcoin_primitives::script::Script<T>) -> bool
+pub fn bitcoin_primitives::script::Script<T>::eq(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> bool
+pub fn bitcoin_primitives::script::Script<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::Script<T>::from_bytes_mut(bytes: &mut [u8]) -> &mut Self
+pub fn bitcoin_primitives::script::Script<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script<T>::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf<T>
+pub fn bitcoin_primitives::script::Script<T>::partial_cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script<T>::to_bytes(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::Script<T>::to_owned(&self) -> Self::Owned
+pub fn bitcoin_primitives::script::Script<T>::to_vec(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_ref(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::as_script(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::borrow(&self) -> &bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::capacity(&self) -> usize
+pub fn bitcoin_primitives::script::ScriptBuf<T>::clone(&self) -> bitcoin_primitives::script::ScriptBuf<T>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptBuf<T>::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::script::ScriptBuf<T>::default() -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::deref(&self) -> &Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf<T>::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf<T>::eq(&self, other: &bitcoin_primitives::script::Script<T>) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf<T>::eq(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(v: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(value: &'a bitcoin_primitives::script::Script<T>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script<T>>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script<T>>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::into_bytes(self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::partial_cmp(&self, other: &bitcoin_primitives::script::Script<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf<T>::reserve(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::reserve_exact(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf<T>::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::default() -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::script::ScriptBufDecoder<T>::read_limit(&self) -> usize
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::clone(&self) -> bitcoin_primitives::script::ScriptBufDecoderError
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::eq(&self, other: &bitcoin_primitives::script::ScriptBufDecoderError) -> bool
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::ByteVecDecoderError) -> Self
+pub fn bitcoin_primitives::script::ScriptBufDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::ScriptEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::script::ScriptEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
+pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptHash::from_script<T>(redeem_script: &bitcoin_primitives::script::Script<T>) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError> where T: bitcoin_primitives::script::ScriptHashableTag
+pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked<T>(script: &bitcoin_primitives::script::Script<T>) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf<T>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::clone(&self) -> bitcoin_primitives::script::ScriptPubKeyTag
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::cmp(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::eq(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> bool
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptPubKeyTag::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptPubKeyTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptSigTag::clone(&self) -> bitcoin_primitives::script::ScriptSigTag
+pub fn bitcoin_primitives::script::ScriptSigTag::cmp(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptSigTag::eq(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> bool
+pub fn bitcoin_primitives::script::ScriptSigTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptSigTag::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptSigTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::TapScriptTag::clone(&self) -> bitcoin_primitives::script::TapScriptTag
+pub fn bitcoin_primitives::script::TapScriptTag::cmp(&self, other: &bitcoin_primitives::script::TapScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::TapScriptTag::eq(&self, other: &bitcoin_primitives::script::TapScriptTag) -> bool
+pub fn bitcoin_primitives::script::TapScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::TapScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::TapScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
+pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::WitnessScript) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
+pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::WitnessScript) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::WitnessScript) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::WitnessScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::WitnessScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::invalid_size(&self) -> usize
+pub fn bitcoin_primitives::script::WitnessScriptTag::clone(&self) -> bitcoin_primitives::script::WitnessScriptTag
+pub fn bitcoin_primitives::script::WitnessScriptTag::cmp(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WitnessScriptTag::eq(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WitnessScriptTag::partial_cmp(&self, other: &bitcoin_primitives::script::WitnessScriptTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::OutPoint::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::OutPointDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::clone(&self) -> bitcoin_primitives::transaction::OutPointDecoderError
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::eq(&self, other: &bitcoin_primitives::transaction::OutPointDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
+pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_primitives::Ntxid
+pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::Txid
+pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::Wtxid
+pub fn bitcoin_primitives::transaction::Transaction::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::Transaction::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Transaction::is_coinbase(&self) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TransactionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::clone(&self) -> bitcoin_primitives::transaction::TransactionDecoderError
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TransactionDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxInDecoderError>) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::VecDecoderError<bitcoin_primitives::transaction::TxOutDecoderError>) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_primitives::transaction::VersionDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_primitives::witness::WitnessDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(e: bitcoin_units::locktime::absolute::error::LockTimeDecoderError) -> Self
+pub fn bitcoin_primitives::transaction::TransactionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TransactionEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TransactionEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
+pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxIn::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::TxIn::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
+pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxInDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxInDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxInDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxInDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxInDecoderError
+pub fn bitcoin_primitives::transaction::TxInDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxInDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxInDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxInDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxInEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TxInEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxMerkleNodeDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
+pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxOut::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::TxOut::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
+pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxOutDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxOutDecoderError
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxOutDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOutDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::TxOutEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::TxOutEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::VersionDecoderError::clone(&self) -> bitcoin_primitives::transaction::VersionDecoderError
+pub fn bitcoin_primitives::transaction::VersionDecoderError::eq(&self, other: &bitcoin_primitives::transaction::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::WitnessesEncoder<'e>::new(inputs: &'e [bitcoin_primitives::transaction::TxIn]) -> Self
+pub fn bitcoin_primitives::witness::Iter<'a>::clone(&self) -> bitcoin_primitives::witness::Iter<'a>
+pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn bitcoin_primitives::witness::UnexpectedEofError::clone(&self) -> bitcoin_primitives::witness::UnexpectedEofError
+pub fn bitcoin_primitives::witness::UnexpectedEofError::eq(&self, other: &bitcoin_primitives::witness::UnexpectedEofError) -> bool
+pub fn bitcoin_primitives::witness::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
+pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
+pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
+pub fn bitcoin_primitives::witness::Witness::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::witness::Witness::default() -> Self
+pub fn bitcoin_primitives::witness::Witness::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &&[T; N]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &&[T]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &[T; N]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &[T]) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::boxed::Box<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::rc::Rc<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::sync::Arc<[T]>) -> bool
+pub fn bitcoin_primitives::witness::Witness::eq(&self, rhs: &alloc::vec::Vec<T>) -> bool
+pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::Witness::from(arr: &[&[u8]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(arr: [&[u8]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8; N]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[[u8; N]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: [&[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: [[u8; M]; N]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_iter<I: core::iter::traits::collect::IntoIterator<Item = T>>(iter: I) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
+pub fn bitcoin_primitives::witness::Witness::get(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::get_back(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
+pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
+pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
+pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
+pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
+pub fn bitcoin_primitives::witness::WitnessDecoder::default() -> Self
+pub fn bitcoin_primitives::witness::WitnessDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::witness::WitnessDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::witness::WitnessDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::witness::WitnessDecoderError::clone(&self) -> bitcoin_primitives::witness::WitnessDecoderError
+pub fn bitcoin_primitives::witness::WitnessDecoderError::eq(&self, other: &bitcoin_primitives::witness::WitnessDecoderError) -> bool
+pub fn bitcoin_primitives::witness::WitnessDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::witness::WitnessDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::witness::WitnessEncoder<'_>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::witness::WitnessEncoder<'_>::current_chunk(&self) -> &[u8]
+pub fn u32::from(version: bitcoin_primitives::transaction::Version) -> Self
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::script
+pub mod bitcoin_primitives::transaction
+pub mod bitcoin_primitives::witness
+pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::BlockVersion(_)
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Ntxid(_)
+pub struct bitcoin_primitives::OutPoint
+pub struct bitcoin_primitives::Transaction
+pub struct bitcoin_primitives::TransactionVersion(_)
+pub struct bitcoin_primitives::TxIn
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::TxOut
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::Witness
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::block::BlockDecoder(_)
+pub struct bitcoin_primitives::block::BlockDecoderError(_)
+pub struct bitcoin_primitives::block::BlockEncoder<'e>(_)
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::BlockHashDecoder(_)
+pub struct bitcoin_primitives::block::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::block::BlockHashEncoder(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::HeaderDecoder(_)
+pub struct bitcoin_primitives::block::HeaderEncoder(_)
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::VersionDecoder(_)
+pub struct bitcoin_primitives::block::VersionDecoderError(_)
+pub struct bitcoin_primitives::block::VersionEncoder(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoder(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoderError(_)
+pub struct bitcoin_primitives::pow::CompactTargetEncoder(_)
+pub struct bitcoin_primitives::script::RedeemScriptSizeError
+pub struct bitcoin_primitives::script::ScriptBuf<T>(_, _)
+pub struct bitcoin_primitives::script::ScriptBufDecoder<T>(_, _)
+pub struct bitcoin_primitives::script::ScriptBufDecoderError(_)
+pub struct bitcoin_primitives::script::ScriptEncoder<'e>(_)
+pub struct bitcoin_primitives::script::ScriptHash(_)
+pub struct bitcoin_primitives::script::WScriptHash(_)
+pub struct bitcoin_primitives::script::WitnessScriptSizeError
+pub struct bitcoin_primitives::transaction::BlockHashDecoder(_)
+pub struct bitcoin_primitives::transaction::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::transaction::Ntxid(_)
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::OutPointDecoder(_)
+pub struct bitcoin_primitives::transaction::OutPointDecoderError(_)
+pub struct bitcoin_primitives::transaction::OutPointEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::Transaction
+pub struct bitcoin_primitives::transaction::TransactionDecoder
+pub struct bitcoin_primitives::transaction::TransactionDecoderError(_)
+pub struct bitcoin_primitives::transaction::TransactionEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::TxIn
+pub struct bitcoin_primitives::transaction::TxInDecoder(_)
+pub struct bitcoin_primitives::transaction::TxInDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxInEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoder(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxOut
+pub struct bitcoin_primitives::transaction::TxOutDecoder(_)
+pub struct bitcoin_primitives::transaction::TxOutDecoderError(_)
+pub struct bitcoin_primitives::transaction::TxOutEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(_)
+pub struct bitcoin_primitives::transaction::VersionDecoder(_)
+pub struct bitcoin_primitives::transaction::VersionDecoderError(_)
+pub struct bitcoin_primitives::transaction::VersionEncoder(_)
+pub struct bitcoin_primitives::transaction::WitnessesEncoder<'e>
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub struct bitcoin_primitives::witness::Iter<'a>
+pub struct bitcoin_primitives::witness::UnexpectedEofError
+pub struct bitcoin_primitives::witness::Witness
+pub struct bitcoin_primitives::witness::WitnessDecoder
+pub struct bitcoin_primitives::witness::WitnessDecoderError(_)
+pub struct bitcoin_primitives::witness::WitnessEncoder<'a>(_)
+pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::script::ScriptHashableTag: bitcoin_primitives::script::sealed::Sealed
+pub trait bitcoin_primitives::script::Tag
+pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
+pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
+pub type bitcoin_primitives::BlockHash::Decoder = bitcoin_primitives::block::BlockHashDecoder
+pub type bitcoin_primitives::BlockHash::Encoder<'e> = bitcoin_primitives::block::BlockHashEncoder
+pub type bitcoin_primitives::RedeemScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::RedeemScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::ScriptPubKey = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::ScriptPubKeyBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::ScriptSig = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::ScriptSigBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::TapScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::TapScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::TxMerkleNode::Decoder = bitcoin_primitives::transaction::TxMerkleNodeDecoder
+pub type bitcoin_primitives::TxMerkleNode::Encoder<'e> = bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+pub type bitcoin_primitives::WitnessMerkleNode::Decoder = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeDecoder
+pub type bitcoin_primitives::WitnessMerkleNode::Encoder<'e> = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeEncoder
+pub type bitcoin_primitives::WitnessScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::WitnessScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::block::Block::Decoder = bitcoin_primitives::block::BlockDecoder
+pub type bitcoin_primitives::block::Block::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_primitives::block::HeaderEncoder, bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_consensus_encoding::encode::encoders::CompactSizeEncoder, bitcoin_consensus_encoding::encode::encoders::SliceEncoder<'e, bitcoin_primitives::transaction::Transaction>>>
+pub type bitcoin_primitives::block::BlockDecoder::Error = bitcoin_primitives::block::BlockDecoderError
+pub type bitcoin_primitives::block::BlockDecoder::Output = bitcoin_primitives::block::Block
+pub type bitcoin_primitives::block::BlockHashDecoder::Error = bitcoin_primitives::block::BlockHashDecoderError
+pub type bitcoin_primitives::block::BlockHashDecoder::Output = bitcoin_primitives::BlockHash
+pub type bitcoin_primitives::block::Header::Decoder = bitcoin_primitives::block::HeaderDecoder
+pub type bitcoin_primitives::block::Header::Encoder<'e> = bitcoin_primitives::block::HeaderEncoder
+pub type bitcoin_primitives::block::HeaderDecoder::Error = bitcoin_primitives::block::HeaderDecoderError
+pub type bitcoin_primitives::block::HeaderDecoder::Output = bitcoin_primitives::block::Header
+pub type bitcoin_primitives::block::Version::Decoder = bitcoin_primitives::block::VersionDecoder
+pub type bitcoin_primitives::block::Version::Encoder<'e> = bitcoin_primitives::block::VersionEncoder
+pub type bitcoin_primitives::block::VersionDecoder::Error = bitcoin_primitives::block::VersionDecoderError
+pub type bitcoin_primitives::block::VersionDecoder::Output = bitcoin_primitives::block::Version
+pub type bitcoin_primitives::pow::CompactTarget::Decoder = bitcoin_primitives::pow::CompactTargetDecoder
+pub type bitcoin_primitives::pow::CompactTarget::Encoder<'e> = bitcoin_primitives::pow::CompactTargetEncoder
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Error = bitcoin_primitives::pow::CompactTargetDecoderError
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Output = bitcoin_primitives::pow::CompactTarget
+pub type bitcoin_primitives::script::RedeemScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::script::RedeemScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::RedeemScriptTag>
+pub type bitcoin_primitives::script::Script<T>::Encoder<'a> where Self: 'a = bitcoin_primitives::script::ScriptEncoder<'a>
+pub type bitcoin_primitives::script::Script<T>::Output = bitcoin_primitives::script::Script<T>
+pub type bitcoin_primitives::script::Script<T>::Owned = bitcoin_primitives::script::ScriptBuf<T>
+pub type bitcoin_primitives::script::ScriptBuf<T>::Decoder = bitcoin_primitives::script::ScriptBufDecoder<T>
+pub type bitcoin_primitives::script::ScriptBuf<T>::Target = bitcoin_primitives::script::Script<T>
+pub type bitcoin_primitives::script::ScriptBufDecoder<T>::Error = bitcoin_primitives::script::ScriptBufDecoderError
+pub type bitcoin_primitives::script::ScriptBufDecoder<T>::Output = bitcoin_primitives::script::ScriptBuf<T>
+pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
+pub type bitcoin_primitives::script::ScriptPubKey = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptPubKeyBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptPubKeyBufDecoder = bitcoin_primitives::script::ScriptBufDecoder<bitcoin_primitives::script::ScriptPubKeyTag>
+pub type bitcoin_primitives::script::ScriptSig = bitcoin_primitives::script::Script<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::ScriptSigBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::ScriptSigBufDecoder = bitcoin_primitives::script::ScriptBufDecoder<bitcoin_primitives::script::ScriptSigTag>
+pub type bitcoin_primitives::script::TapScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::script::TapScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::TapScriptTag>
+pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
+pub type bitcoin_primitives::script::WitnessScript = bitcoin_primitives::script::Script<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::script::WitnessScriptBuf = bitcoin_primitives::script::ScriptBuf<bitcoin_primitives::script::WitnessScriptTag>
+pub type bitcoin_primitives::transaction::OutPoint::Decoder = bitcoin_primitives::transaction::OutPointDecoder
+pub type bitcoin_primitives::transaction::OutPoint::Encoder<'e> where Self: 'e = bitcoin_primitives::transaction::OutPointEncoder<'e>
+pub type bitcoin_primitives::transaction::OutPointDecoder::Error = bitcoin_primitives::transaction::OutPointDecoderError
+pub type bitcoin_primitives::transaction::OutPointDecoder::Output = bitcoin_primitives::transaction::OutPoint
+pub type bitcoin_primitives::transaction::Transaction::Decoder = bitcoin_primitives::transaction::TransactionDecoder
+pub type bitcoin_primitives::transaction::Transaction::Encoder<'e> where Self: 'e = bitcoin_primitives::transaction::TransactionEncoder<'e>
+pub type bitcoin_primitives::transaction::TransactionDecoder::Error = bitcoin_primitives::transaction::TransactionDecoderError
+pub type bitcoin_primitives::transaction::TransactionDecoder::Output = bitcoin_primitives::transaction::Transaction
+pub type bitcoin_primitives::transaction::TxIn::Decoder = bitcoin_primitives::transaction::TxInDecoder
+pub type bitcoin_primitives::transaction::TxIn::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder3<bitcoin_primitives::transaction::OutPointEncoder<'e>, bitcoin_primitives::script::ScriptEncoder<'e>, bitcoin_units::sequence::SequenceEncoder>
+pub type bitcoin_primitives::transaction::TxInDecoder::Error = bitcoin_primitives::transaction::TxInDecoderError
+pub type bitcoin_primitives::transaction::TxInDecoder::Output = bitcoin_primitives::transaction::TxIn
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Error = bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Output = bitcoin_primitives::TxMerkleNode
+pub type bitcoin_primitives::transaction::TxOut::Decoder = bitcoin_primitives::transaction::TxOutDecoder
+pub type bitcoin_primitives::transaction::TxOut::Encoder<'e> where Self: 'e = bitcoin_consensus_encoding::encode::encoders::Encoder2<bitcoin_units::amount::unsigned::AmountEncoder, bitcoin_primitives::script::ScriptEncoder<'e>>
+pub type bitcoin_primitives::transaction::TxOutDecoder::Error = bitcoin_primitives::transaction::TxOutDecoderError
+pub type bitcoin_primitives::transaction::TxOutDecoder::Output = bitcoin_primitives::transaction::TxOut
+pub type bitcoin_primitives::transaction::Version::Decoder = bitcoin_primitives::transaction::VersionDecoder
+pub type bitcoin_primitives::transaction::Version::Encoder<'e> = bitcoin_primitives::transaction::VersionEncoder
+pub type bitcoin_primitives::transaction::VersionDecoder::Error = bitcoin_primitives::transaction::VersionDecoderError
+pub type bitcoin_primitives::transaction::VersionDecoder::Output = bitcoin_primitives::transaction::Version
+pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
+pub type bitcoin_primitives::witness::Witness::Decoder = bitcoin_primitives::witness::WitnessDecoder
+pub type bitcoin_primitives::witness::Witness::Encoder<'a> where Self: 'a = bitcoin_primitives::witness::WitnessEncoder<'a>
+pub type bitcoin_primitives::witness::Witness::Output = [u8]
+pub type bitcoin_primitives::witness::WitnessDecoder::Error = bitcoin_primitives::witness::WitnessDecoderError
+pub type bitcoin_primitives::witness::WitnessDecoder::Output = bitcoin_primitives::witness::Witness
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockHeightInterval
+pub use bitcoin_primitives::BlockMtp
+pub use bitcoin_primitives::BlockMtpInterval
+pub use bitcoin_primitives::BlockTime
+pub use bitcoin_primitives::BlockTimeDecoder
+pub use bitcoin_primitives::BlockTimeDecoderError
+pub use bitcoin_primitives::FeeRate
+pub use bitcoin_primitives::NumOpResult
+pub use bitcoin_primitives::Sequence
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute
+pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::block::BlockHeight
+pub use bitcoin_primitives::block::BlockHeightDecoder
+pub use bitcoin_primitives::block::BlockHeightDecoderError
+pub use bitcoin_primitives::block::BlockHeightEncoder
+pub use bitcoin_primitives::block::BlockHeightInterval
+pub use bitcoin_primitives::block::BlockMtp
+pub use bitcoin_primitives::block::BlockMtpInterval
+pub use bitcoin_primitives::block::TooBigForRelativeHeightError
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime
+pub use bitcoin_primitives::parse_int
+pub use bitcoin_primitives::relative
+pub use bitcoin_primitives::result
+pub use bitcoin_primitives::sequence
+pub use bitcoin_primitives::time
+pub use bitcoin_primitives::weight
diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
new file mode 100644
index 0000000000..9a8113810b
--- /dev/null
+++ b/api/primitives/no-features.txt
@@ -0,0 +1,789 @@
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::block::VersionDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_primitives::transaction::VersionDecoder
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::BlockHash
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::TxMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Header
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::block::Version
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::pow::CompactTarget
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::OutPoint
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_primitives::transaction::Version
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::BlockHashEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::HeaderEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::block::VersionEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::pow::CompactTargetEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::VersionEncoder
+impl bitcoin_primitives::BlockHash
+impl bitcoin_primitives::Ntxid
+impl bitcoin_primitives::TxMerkleNode
+impl bitcoin_primitives::Txid
+impl bitcoin_primitives::WitnessCommitment
+impl bitcoin_primitives::WitnessMerkleNode
+impl bitcoin_primitives::Wtxid
+impl bitcoin_primitives::block::BlockHashDecoder
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::VersionDecoder
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::pow::CompactTargetDecoder
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::OutPointDecoder
+impl bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::VersionDecoder
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Ntxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::Wtxid
+impl core::clone::Clone for bitcoin_primitives::BlockHash
+impl core::clone::Clone for bitcoin_primitives::Ntxid
+impl core::clone::Clone for bitcoin_primitives::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Txid
+impl core::clone::Clone for bitcoin_primitives::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::Wtxid
+impl core::clone::Clone for bitcoin_primitives::block::BlockHashDecoderError
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::VersionDecoderError
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::Ntxid
+impl core::cmp::Eq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Txid
+impl core::cmp::Eq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::Ord for bitcoin_primitives::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::Ntxid
+impl core::cmp::Ord for bitcoin_primitives::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Txid
+impl core::cmp::Ord for bitcoin_primitives::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::Ntxid
+impl core::cmp::PartialEq for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::cmp::PartialOrd for bitcoin_primitives::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::Ntxid
+impl core::cmp::PartialOrd for bitcoin_primitives::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Ntxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::Wtxid
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::BlockHash
+impl core::convert::From<bitcoin_primitives::transaction::Version> for u32
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::BlockHashDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::block::VersionDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::VersionDecoderError
+impl core::default::Default for bitcoin_primitives::block::BlockHashDecoder
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::block::VersionDecoder
+impl core::default::Default for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::default::Default for bitcoin_primitives::transaction::OutPointDecoder
+impl core::default::Default for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::default::Default for bitcoin_primitives::transaction::VersionDecoder
+impl core::fmt::Debug for bitcoin_primitives::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::Ntxid
+impl core::fmt::Debug for bitcoin_primitives::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Txid
+impl core::fmt::Debug for bitcoin_primitives::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::Wtxid
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::BlockHashDecoderError
+impl core::fmt::Display for bitcoin_primitives::block::VersionDecoderError
+impl core::fmt::Display for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::VersionDecoderError
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::BlockHash
+impl core::hash::Hash for bitcoin_primitives::Ntxid
+impl core::hash::Hash for bitcoin_primitives::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Txid
+impl core::hash::Hash for bitcoin_primitives::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::marker::Copy for bitcoin_primitives::BlockHash
+impl core::marker::Copy for bitcoin_primitives::Ntxid
+impl core::marker::Copy for bitcoin_primitives::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Txid
+impl core::marker::Copy for bitcoin_primitives::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::Wtxid
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::Ntxid
+impl core::marker::Freeze for bitcoin_primitives::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Txid
+impl core::marker::Freeze for bitcoin_primitives::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Freeze for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::BlockHash
+impl core::marker::Send for bitcoin_primitives::Ntxid
+impl core::marker::Send for bitcoin_primitives::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::Txid
+impl core::marker::Send for bitcoin_primitives::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::Wtxid
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Send for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Send for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Send for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Send for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Send for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::StructuralPartialEq for bitcoin_primitives::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Ntxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::BlockHash
+impl core::marker::Sync for bitcoin_primitives::Ntxid
+impl core::marker::Sync for bitcoin_primitives::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Txid
+impl core::marker::Sync for bitcoin_primitives::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::Wtxid
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Sync for bitcoin_primitives::transaction::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::Ntxid
+impl core::marker::Unpin for bitcoin_primitives::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Txid
+impl core::marker::Unpin for bitcoin_primitives::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHashEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::HeaderEncoder
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::block::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::block::VersionEncoder
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoder
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionDecoderError
+impl core::marker::Unpin for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Ntxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHashEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::HeaderEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::VersionEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTargetEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::VersionEncoder
+impl<'e> bitcoin_consensus_encoding::encode::Encoder for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Freeze for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Send for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Sync for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::marker::Unpin for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+impl<'e> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPointEncoder<'e>
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::BlockHeader::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::OutPoint::vout: u32
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::BlockHash
+pub bitcoin_primitives::block::Header::time: bitcoin_units::time::encapsulate::BlockTime
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub const bitcoin_primitives::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::WitnessCommitment::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const fn bitcoin_primitives::BlockHash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::BlockHash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::BlockHash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Ntxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Ntxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Ntxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::TxMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::TxMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Txid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Txid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Txid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessCommitment::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessCommitment::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::WitnessMerkleNode::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::WitnessMerkleNode::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::Wtxid::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_primitives::Wtxid::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_primitives::Wtxid::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_primitives::block::BlockHashDecoder::new() -> Self
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub const fn bitcoin_primitives::block::VersionDecoder::new() -> Self
+pub const fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub const fn bitcoin_primitives::pow::CompactTargetDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::OutPointDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::new() -> Self
+pub const fn bitcoin_primitives::transaction::Version::is_standard(self) -> bool
+pub const fn bitcoin_primitives::transaction::Version::maybe_non_standard(version: u32) -> Self
+pub const fn bitcoin_primitives::transaction::Version::to_u32(self) -> u32
+pub const fn bitcoin_primitives::transaction::VersionDecoder::new() -> Self
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::BlockHash::clone(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::BlockHash::cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::BlockHash::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::BlockHash::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::BlockHash::eq(&self, other: &bitcoin_primitives::BlockHash) -> bool
+pub fn bitcoin_primitives::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::BlockHash::from(header: &bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::from(header: bitcoin_primitives::block::Header) -> Self
+pub fn bitcoin_primitives::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Ntxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Ntxid::clone(&self) -> bitcoin_primitives::Ntxid
+pub fn bitcoin_primitives::Ntxid::cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Ntxid::eq(&self, other: &bitcoin_primitives::Ntxid) -> bool
+pub fn bitcoin_primitives::Ntxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Ntxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Ntxid::partial_cmp(&self, other: &bitcoin_primitives::Ntxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::TxMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Txid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::TxMerkleNode::clone(&self) -> bitcoin_primitives::TxMerkleNode
+pub fn bitcoin_primitives::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::TxMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::TxMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::TxMerkleNode::eq(&self, other: &bitcoin_primitives::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::TxMerkleNode::from_leaf(leaf: bitcoin_primitives::Txid) -> Self
+pub fn bitcoin_primitives::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Txid::clone(&self) -> bitcoin_primitives::Txid
+pub fn bitcoin_primitives::Txid::cmp(&self, other: &bitcoin_primitives::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Txid::eq(&self, other: &bitcoin_primitives::Txid) -> bool
+pub fn bitcoin_primitives::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Txid::partial_cmp(&self, other: &bitcoin_primitives::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessCommitment::clone(&self) -> bitcoin_primitives::WitnessCommitment
+pub fn bitcoin_primitives::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessCommitment::eq(&self, other: &bitcoin_primitives::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::WitnessMerkleNode::calculate_root<I: core::iter::traits::iterator::Iterator<Item = bitcoin_primitives::Wtxid>>(iter: I) -> core::option::Option<Self>
+pub fn bitcoin_primitives::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::WitnessMerkleNode
+pub fn bitcoin_primitives::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::WitnessMerkleNode::combine(&self, other: &Self) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::WitnessMerkleNode::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::WitnessMerkleNode::from_leaf(leaf: bitcoin_primitives::Wtxid) -> Self
+pub fn bitcoin_primitives::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::Wtxid::clone(&self) -> bitcoin_primitives::Wtxid
+pub fn bitcoin_primitives::Wtxid::cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::Wtxid::eq(&self, other: &bitcoin_primitives::Wtxid) -> bool
+pub fn bitcoin_primitives::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::BlockHashDecoder::default() -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::BlockHashDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::BlockHashDecoderError::clone(&self) -> bitcoin_primitives::block::BlockHashDecoderError
+pub fn bitcoin_primitives::block::BlockHashDecoderError::eq(&self, other: &bitcoin_primitives::block::BlockHashDecoderError) -> bool
+pub fn bitcoin_primitives::block::BlockHashDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::BlockHashDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::BlockHashEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::BlockHashEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::HeaderEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::HeaderEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::block::Version::default() -> Self
+pub fn bitcoin_primitives::block::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::block::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::block::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::block::VersionDecoderError::clone(&self) -> bitcoin_primitives::block::VersionDecoderError
+pub fn bitcoin_primitives::block::VersionDecoderError::eq(&self, other: &bitcoin_primitives::block::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::block::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::VersionDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::block::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::block::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::block::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::pow::CompactTarget::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::default() -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::pow::CompactTargetDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::clone(&self) -> bitcoin_primitives::pow::CompactTargetDecoderError
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::eq(&self, other: &bitcoin_primitives::pow::CompactTargetDecoderError) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::pow::CompactTargetEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::OutPoint::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::OutPointDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::OutPointDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::clone(&self) -> bitcoin_primitives::transaction::OutPointDecoderError
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::eq(&self, other: &bitcoin_primitives::transaction::OutPointDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::OutPointDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::OutPointEncoder<'e>::current_chunk(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::clone(&self) -> bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::eq(&self, other: &bitcoin_primitives::transaction::TxMerkleNodeDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(e: bitcoin_consensus_encoding::decode::decoders::UnexpectedEofError) -> Self
+pub fn bitcoin_primitives::transaction::TxMerkleNodeDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::decoder() -> Self::Decoder
+pub fn bitcoin_primitives::transaction::Version::encoder(&self) -> Self::Encoder
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::VersionDecoder::default() -> Self
+pub fn bitcoin_primitives::transaction::VersionDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_primitives::transaction::VersionDecoder::read_limit(&self) -> usize
+pub fn bitcoin_primitives::transaction::VersionDecoderError::clone(&self) -> bitcoin_primitives::transaction::VersionDecoderError
+pub fn bitcoin_primitives::transaction::VersionDecoderError::eq(&self, other: &bitcoin_primitives::transaction::VersionDecoderError) -> bool
+pub fn bitcoin_primitives::transaction::VersionDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::VersionDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::VersionEncoder::advance(&mut self) -> bool
+pub fn bitcoin_primitives::transaction::VersionEncoder::current_chunk(&self) -> &[u8]
+pub fn u32::from(version: bitcoin_primitives::transaction::Version) -> Self
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::transaction
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::BlockVersion(_)
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Ntxid(_)
+pub struct bitcoin_primitives::OutPoint
+pub struct bitcoin_primitives::TransactionVersion(_)
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::BlockHashDecoder(_)
+pub struct bitcoin_primitives::block::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::block::BlockHashEncoder(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::HeaderEncoder(_)
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::VersionDecoder(_)
+pub struct bitcoin_primitives::block::VersionDecoderError(_)
+pub struct bitcoin_primitives::block::VersionEncoder(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoder(_)
+pub struct bitcoin_primitives::pow::CompactTargetDecoderError(_)
+pub struct bitcoin_primitives::pow::CompactTargetEncoder(_)
+pub struct bitcoin_primitives::transaction::BlockHashDecoder(_)
+pub struct bitcoin_primitives::transaction::BlockHashDecoderError(_)
+pub struct bitcoin_primitives::transaction::Ntxid(_)
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::OutPointDecoder(_)
+pub struct bitcoin_primitives::transaction::OutPointDecoderError(_)
+pub struct bitcoin_primitives::transaction::OutPointEncoder<'e>(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoder(_)
+pub struct bitcoin_primitives::transaction::TxMerkleNodeDecoderError(_)
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(_)
+pub struct bitcoin_primitives::transaction::VersionDecoder(_)
+pub struct bitcoin_primitives::transaction::VersionDecoderError(_)
+pub struct bitcoin_primitives::transaction::VersionEncoder(_)
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub type bitcoin_primitives::BlockHash::Decoder = bitcoin_primitives::block::BlockHashDecoder
+pub type bitcoin_primitives::BlockHash::Encoder<'e> = bitcoin_primitives::block::BlockHashEncoder
+pub type bitcoin_primitives::TxMerkleNode::Decoder = bitcoin_primitives::transaction::TxMerkleNodeDecoder
+pub type bitcoin_primitives::TxMerkleNode::Encoder<'e> = bitcoin_primitives::merkle_tree::TxMerkleNodeEncoder
+pub type bitcoin_primitives::WitnessMerkleNode::Decoder = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeDecoder
+pub type bitcoin_primitives::WitnessMerkleNode::Encoder<'e> = bitcoin_primitives::hash_types::witness_merkle_node::WitnessMerkleNodeEncoder
+pub type bitcoin_primitives::block::BlockHashDecoder::Error = bitcoin_primitives::block::BlockHashDecoderError
+pub type bitcoin_primitives::block::BlockHashDecoder::Output = bitcoin_primitives::BlockHash
+pub type bitcoin_primitives::block::Header::Encoder<'e> = bitcoin_primitives::block::HeaderEncoder
+pub type bitcoin_primitives::block::Version::Decoder = bitcoin_primitives::block::VersionDecoder
+pub type bitcoin_primitives::block::Version::Encoder<'e> = bitcoin_primitives::block::VersionEncoder
+pub type bitcoin_primitives::block::VersionDecoder::Error = bitcoin_primitives::block::VersionDecoderError
+pub type bitcoin_primitives::block::VersionDecoder::Output = bitcoin_primitives::block::Version
+pub type bitcoin_primitives::pow::CompactTarget::Decoder = bitcoin_primitives::pow::CompactTargetDecoder
+pub type bitcoin_primitives::pow::CompactTarget::Encoder<'e> = bitcoin_primitives::pow::CompactTargetEncoder
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Error = bitcoin_primitives::pow::CompactTargetDecoderError
+pub type bitcoin_primitives::pow::CompactTargetDecoder::Output = bitcoin_primitives::pow::CompactTarget
+pub type bitcoin_primitives::transaction::OutPoint::Decoder = bitcoin_primitives::transaction::OutPointDecoder
+pub type bitcoin_primitives::transaction::OutPoint::Encoder<'e> where Self: 'e = bitcoin_primitives::transaction::OutPointEncoder<'e>
+pub type bitcoin_primitives::transaction::OutPointDecoder::Error = bitcoin_primitives::transaction::OutPointDecoderError
+pub type bitcoin_primitives::transaction::OutPointDecoder::Output = bitcoin_primitives::transaction::OutPoint
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Error = bitcoin_primitives::transaction::TxMerkleNodeDecoderError
+pub type bitcoin_primitives::transaction::TxMerkleNodeDecoder::Output = bitcoin_primitives::TxMerkleNode
+pub type bitcoin_primitives::transaction::Version::Decoder = bitcoin_primitives::transaction::VersionDecoder
+pub type bitcoin_primitives::transaction::Version::Encoder<'e> = bitcoin_primitives::transaction::VersionEncoder
+pub type bitcoin_primitives::transaction::VersionDecoder::Error = bitcoin_primitives::transaction::VersionDecoderError
+pub type bitcoin_primitives::transaction::VersionDecoder::Output = bitcoin_primitives::transaction::Version
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockHeightInterval
+pub use bitcoin_primitives::BlockMtp
+pub use bitcoin_primitives::BlockMtpInterval
+pub use bitcoin_primitives::BlockTime
+pub use bitcoin_primitives::BlockTimeDecoder
+pub use bitcoin_primitives::BlockTimeDecoderError
+pub use bitcoin_primitives::FeeRate
+pub use bitcoin_primitives::NumOpResult
+pub use bitcoin_primitives::Sequence
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute
+pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::block::BlockHeight
+pub use bitcoin_primitives::block::BlockHeightDecoder
+pub use bitcoin_primitives::block::BlockHeightDecoderError
+pub use bitcoin_primitives::block::BlockHeightEncoder
+pub use bitcoin_primitives::block::BlockHeightInterval
+pub use bitcoin_primitives::block::BlockMtp
+pub use bitcoin_primitives::block::BlockMtpInterval
+pub use bitcoin_primitives::block::TooBigForRelativeHeightError
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime
+pub use bitcoin_primitives::parse_int
+pub use bitcoin_primitives::relative
+pub use bitcoin_primitives::result
+pub use bitcoin_primitives::sequence
+pub use bitcoin_primitives::time
+pub use bitcoin_primitives::weight
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
new file mode 100644
index 0000000000..50fc84ca62
--- /dev/null
+++ b/api/units/all-features.txt
@@ -0,0 +1,2865 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::result::MathOp
+#[non_exhaustive] pub struct bitcoin_units::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::fee_rate::serde::OverflowError
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse_int::ParseIntError
+#[non_exhaustive] pub struct bitcoin_units::result::NumOpError(_)
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_units::Amount
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_units::BlockTime
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_units::block::BlockHeight
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_units::locktime::absolute::LockTime
+impl bitcoin_consensus_encoding::decode::Decodable for bitcoin_units::sequence::Sequence
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_units::amount::AmountDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_units::block::BlockHeightDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_units::sequence::SequenceDecoder
+impl bitcoin_consensus_encoding::decode::Decoder for bitcoin_units::time::BlockTimeDecoder
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_units::Amount
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_units::BlockTime
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_units::block::BlockHeight
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_units::locktime::absolute::LockTime
+impl bitcoin_consensus_encoding::encode::Encodable for bitcoin_units::sequence::Sequence
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_units::amount::AmountEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_units::block::BlockHeightEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_units::sequence::SequenceEncoder
+impl bitcoin_consensus_encoding::encode::Encoder for bitcoin_units::time::BlockTimeEncoder
+impl bitcoin_units::Amount
+impl bitcoin_units::BlockTime
+impl bitcoin_units::FeeRate
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::Weight
+impl bitcoin_units::amount::AmountDecoder
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockHeightDecoder
+impl bitcoin_units::block::BlockHeightInterval
+impl bitcoin_units::block::BlockMtp
+impl bitcoin_units::block::BlockMtpInterval
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::LockTime
+impl bitcoin_units::locktime::absolute::LockTimeDecoder
+impl bitcoin_units::locktime::absolute::MedianTimePast
+impl bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl bitcoin_units::locktime::relative::LockTime
+impl bitcoin_units::locktime::relative::NumberOf512Seconds
+impl bitcoin_units::locktime::relative::NumberOfBlocks
+impl bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl bitcoin_units::parse_int::Integer for i128
+impl bitcoin_units::parse_int::Integer for i16
+impl bitcoin_units::parse_int::Integer for i32
+impl bitcoin_units::parse_int::Integer for i64
+impl bitcoin_units::parse_int::Integer for i8
+impl bitcoin_units::parse_int::Integer for u128
+impl bitcoin_units::parse_int::Integer for u16
+impl bitcoin_units::parse_int::Integer for u32
+impl bitcoin_units::parse_int::Integer for u64
+impl bitcoin_units::parse_int::Integer for u8
+impl bitcoin_units::result::MathOp
+impl bitcoin_units::result::NumOpError
+impl bitcoin_units::sequence::Sequence
+impl bitcoin_units::sequence::SequenceDecoder
+impl bitcoin_units::time::BlockTimeDecoder
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::BlockTime
+impl core::clone::Clone for bitcoin_units::FeeRate
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::Weight
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::AmountDecoderError
+impl core::clone::Clone for bitcoin_units::amount::error::BadPositionError
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockHeightDecoderError
+impl core::clone::Clone for bitcoin_units::block::BlockHeightInterval
+impl core::clone::Clone for bitcoin_units::block::BlockMtp
+impl core::clone::Clone for bitcoin_units::block::BlockMtpInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::clone::Clone for bitcoin_units::fee_rate::serde::OverflowError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse_int::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse_int::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse_int::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::result::MathOp
+impl core::clone::Clone for bitcoin_units::result::NumOpError
+impl core::clone::Clone for bitcoin_units::sequence::Sequence
+impl core::clone::Clone for bitcoin_units::sequence::SequenceDecoderError
+impl core::clone::Clone for bitcoin_units::time::BlockTimeDecoderError
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::BlockTime
+impl core::cmp::Eq for bitcoin_units::FeeRate
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::Weight
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::AmountDecoderError
+impl core::cmp::Eq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockHeightDecoderError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Eq for bitcoin_units::block::BlockMtp
+impl core::cmp::Eq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::Eq for bitcoin_units::fee_rate::serde::OverflowError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::result::MathOp
+impl core::cmp::Eq for bitcoin_units::result::NumOpError
+impl core::cmp::Eq for bitcoin_units::sequence::Sequence
+impl core::cmp::Eq for bitcoin_units::sequence::SequenceDecoderError
+impl core::cmp::Eq for bitcoin_units::time::BlockTimeDecoderError
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::BlockTime
+impl core::cmp::Ord for bitcoin_units::FeeRate
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::Weight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Ord for bitcoin_units::block::BlockMtp
+impl core::cmp::Ord for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Ord for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::BlockTime
+impl core::cmp::PartialEq for bitcoin_units::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::Weight
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::AmountDecoderError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeightDecoderError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::PartialEq for bitcoin_units::fee_rate::serde::OverflowError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::result::MathOp
+impl core::cmp::PartialEq for bitcoin_units::result::NumOpError
+impl core::cmp::PartialEq for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_units::sequence::SequenceDecoderError
+impl core::cmp::PartialEq for bitcoin_units::time::BlockTimeDecoderError
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::BlockTime
+impl core::cmp::PartialOrd for bitcoin_units::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::Weight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialOrd for bitcoin_units::sequence::Sequence
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse_int::ParseIntError
+impl core::convert::From<&bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<&bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<bitcoin_units::BlockTime> for u32
+impl core::convert::From<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Weight> for u64
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockHeightInterval> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtp> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtpInterval> for u32
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::block::BlockMtp
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::LockTime> for bitcoin_units::sequence::Sequence
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::sequence::Sequence> for u32
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::AmountDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::block::BlockHeightDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::fee_rate::serde::OverflowError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::sequence::SequenceDecoderError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::time::BlockTimeDecoderError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::From<u32> for bitcoin_units::BlockTime
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtp
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::Weight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<&str> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::Weight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::Weight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<bitcoin_units::block::BlockMtp> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<bitcoin_units::sequence::Sequence> for bitcoin_units::locktime::relative::LockTime
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::amount::AmountDecoder
+impl core::default::Default for bitcoin_units::block::BlockHeightDecoder
+impl core::default::Default for bitcoin_units::block::BlockHeightInterval
+impl core::default::Default for bitcoin_units::block::BlockMtpInterval
+impl core::default::Default for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::default::Default for bitcoin_units::sequence::Sequence
+impl core::default::Default for bitcoin_units::sequence::SequenceDecoder
+impl core::default::Default for bitcoin_units::time::BlockTimeDecoder
+impl core::error::Error for bitcoin_units::amount::error::AmountDecoderError
+impl core::error::Error for bitcoin_units::amount::error::BadPositionError
+impl core::error::Error for bitcoin_units::amount::error::InputTooLargeError
+impl core::error::Error for bitcoin_units::amount::error::InvalidCharacterError
+impl core::error::Error for bitcoin_units::amount::error::MissingDigitsError
+impl core::error::Error for bitcoin_units::amount::error::OutOfRangeError
+impl core::error::Error for bitcoin_units::amount::error::ParseAmountError
+impl core::error::Error for bitcoin_units::amount::error::ParseDenominationError
+impl core::error::Error for bitcoin_units::amount::error::ParseError
+impl core::error::Error for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::error::Error for bitcoin_units::amount::error::TooPreciseError
+impl core::error::Error for bitcoin_units::amount::error::UnknownDenominationError
+impl core::error::Error for bitcoin_units::block::BlockHeightDecoderError
+impl core::error::Error for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::error::Error for bitcoin_units::fee_rate::serde::OverflowError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::error::Error for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::error::Error for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::error::Error for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::error::Error for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::error::Error for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::error::Error for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::error::Error for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::error::Error for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::error::Error for bitcoin_units::parse_int::ParseIntError
+impl core::error::Error for bitcoin_units::parse_int::PrefixedHexError
+impl core::error::Error for bitcoin_units::parse_int::UnprefixedHexError
+impl core::error::Error for bitcoin_units::result::NumOpError
+impl core::error::Error for bitcoin_units::sequence::SequenceDecoderError
+impl core::error::Error for bitcoin_units::time::BlockTimeDecoderError
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::BlockTime
+impl core::fmt::Debug for bitcoin_units::FeeRate
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::Weight
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::AmountDecoderError
+impl core::fmt::Debug for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockHeightDecoderError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Debug for bitcoin_units::block::BlockMtp
+impl core::fmt::Debug for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Debug for bitcoin_units::fee_rate::serde::OverflowError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::result::MathOp
+impl core::fmt::Debug for bitcoin_units::result::NumOpError
+impl core::fmt::Debug for bitcoin_units::sequence::Sequence
+impl core::fmt::Debug for bitcoin_units::sequence::SequenceDecoderError
+impl core::fmt::Debug for bitcoin_units::time::BlockTimeDecoderError
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::Weight
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::AmountDecoderError
+impl core::fmt::Display for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockHeightDecoderError
+impl core::fmt::Display for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Display for bitcoin_units::block::BlockMtp
+impl core::fmt::Display for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Display for bitcoin_units::fee_rate::serde::OverflowError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::result::MathOp
+impl core::fmt::Display for bitcoin_units::result::NumOpError
+impl core::fmt::Display for bitcoin_units::sequence::Sequence
+impl core::fmt::Display for bitcoin_units::sequence::SequenceDecoderError
+impl core::fmt::Display for bitcoin_units::time::BlockTimeDecoderError
+impl core::fmt::LowerHex for bitcoin_units::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_units::sequence::Sequence
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::BlockTime
+impl core::hash::Hash for bitcoin_units::FeeRate
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::Weight
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockHeightInterval
+impl core::hash::Hash for bitcoin_units::block::BlockMtp
+impl core::hash::Hash for bitcoin_units::block::BlockMtpInterval
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::hash::Hash for bitcoin_units::locktime::relative::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::hash::Hash for bitcoin_units::sequence::Sequence
+impl core::iter::traits::accum::Sum for bitcoin_units::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockHeightInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockMtpInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::BlockTime
+impl core::marker::Copy for bitcoin_units::FeeRate
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::Weight
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Copy for bitcoin_units::block::BlockMtp
+impl core::marker::Copy for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Copy for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Copy for bitcoin_units::result::MathOp
+impl core::marker::Copy for bitcoin_units::result::NumOpError
+impl core::marker::Copy for bitcoin_units::sequence::Sequence
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::BlockTime
+impl core::marker::Freeze for bitcoin_units::FeeRate
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::Weight
+impl core::marker::Freeze for bitcoin_units::amount::AmountDecoder
+impl core::marker::Freeze for bitcoin_units::amount::AmountEncoder
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::AmountDecoderError
+impl core::marker::Freeze for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightDecoder
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightDecoderError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightEncoder
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Freeze for bitcoin_units::block::BlockMtp
+impl core::marker::Freeze for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Freeze for bitcoin_units::fee_rate::serde::OverflowError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::result::MathOp
+impl core::marker::Freeze for bitcoin_units::result::NumOpError
+impl core::marker::Freeze for bitcoin_units::sequence::Sequence
+impl core::marker::Freeze for bitcoin_units::sequence::SequenceDecoder
+impl core::marker::Freeze for bitcoin_units::sequence::SequenceDecoderError
+impl core::marker::Freeze for bitcoin_units::sequence::SequenceEncoder
+impl core::marker::Freeze for bitcoin_units::time::BlockTimeDecoder
+impl core::marker::Freeze for bitcoin_units::time::BlockTimeDecoderError
+impl core::marker::Freeze for bitcoin_units::time::BlockTimeEncoder
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::BlockTime
+impl core::marker::Send for bitcoin_units::FeeRate
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::Weight
+impl core::marker::Send for bitcoin_units::amount::AmountDecoder
+impl core::marker::Send for bitcoin_units::amount::AmountEncoder
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::AmountDecoderError
+impl core::marker::Send for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockHeightDecoder
+impl core::marker::Send for bitcoin_units::block::BlockHeightDecoderError
+impl core::marker::Send for bitcoin_units::block::BlockHeightEncoder
+impl core::marker::Send for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Send for bitcoin_units::block::BlockMtp
+impl core::marker::Send for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Send for bitcoin_units::fee_rate::serde::OverflowError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::marker::Send for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::marker::Send for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Send for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Send for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::result::MathOp
+impl core::marker::Send for bitcoin_units::result::NumOpError
+impl core::marker::Send for bitcoin_units::sequence::Sequence
+impl core::marker::Send for bitcoin_units::sequence::SequenceDecoder
+impl core::marker::Send for bitcoin_units::sequence::SequenceDecoderError
+impl core::marker::Send for bitcoin_units::sequence::SequenceEncoder
+impl core::marker::Send for bitcoin_units::time::BlockTimeDecoder
+impl core::marker::Send for bitcoin_units::time::BlockTimeDecoderError
+impl core::marker::Send for bitcoin_units::time::BlockTimeEncoder
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::BlockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::AmountDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeightDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtp
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::serde::OverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::result::MathOp
+impl core::marker::StructuralPartialEq for bitcoin_units::result::NumOpError
+impl core::marker::StructuralPartialEq for bitcoin_units::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_units::sequence::SequenceDecoderError
+impl core::marker::StructuralPartialEq for bitcoin_units::time::BlockTimeDecoderError
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::BlockTime
+impl core::marker::Sync for bitcoin_units::FeeRate
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::Weight
+impl core::marker::Sync for bitcoin_units::amount::AmountDecoder
+impl core::marker::Sync for bitcoin_units::amount::AmountEncoder
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::AmountDecoderError
+impl core::marker::Sync for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockHeightDecoder
+impl core::marker::Sync for bitcoin_units::block::BlockHeightDecoderError
+impl core::marker::Sync for bitcoin_units::block::BlockHeightEncoder
+impl core::marker::Sync for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Sync for bitcoin_units::block::BlockMtp
+impl core::marker::Sync for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Sync for bitcoin_units::fee_rate::serde::OverflowError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::marker::Sync for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::marker::Sync for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::result::MathOp
+impl core::marker::Sync for bitcoin_units::result::NumOpError
+impl core::marker::Sync for bitcoin_units::sequence::Sequence
+impl core::marker::Sync for bitcoin_units::sequence::SequenceDecoder
+impl core::marker::Sync for bitcoin_units::sequence::SequenceDecoderError
+impl core::marker::Sync for bitcoin_units::sequence::SequenceEncoder
+impl core::marker::Sync for bitcoin_units::time::BlockTimeDecoder
+impl core::marker::Sync for bitcoin_units::time::BlockTimeDecoderError
+impl core::marker::Sync for bitcoin_units::time::BlockTimeEncoder
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::BlockTime
+impl core::marker::Unpin for bitcoin_units::FeeRate
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::Weight
+impl core::marker::Unpin for bitcoin_units::amount::AmountDecoder
+impl core::marker::Unpin for bitcoin_units::amount::AmountEncoder
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::AmountDecoderError
+impl core::marker::Unpin for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightDecoder
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightDecoderError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightEncoder
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Unpin for bitcoin_units::block::BlockMtp
+impl core::marker::Unpin for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Unpin for bitcoin_units::fee_rate::serde::OverflowError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::result::MathOp
+impl core::marker::Unpin for bitcoin_units::result::NumOpError
+impl core::marker::Unpin for bitcoin_units::sequence::Sequence
+impl core::marker::Unpin for bitcoin_units::sequence::SequenceDecoder
+impl core::marker::Unpin for bitcoin_units::sequence::SequenceDecoderError
+impl core::marker::Unpin for bitcoin_units::sequence::SequenceEncoder
+impl core::marker::Unpin for bitcoin_units::time::BlockTimeDecoder
+impl core::marker::Unpin for bitcoin_units::time::BlockTimeDecoderError
+impl core::marker::Unpin for bitcoin_units::time::BlockTimeEncoder
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::FeeRate
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::Weight
+impl core::ops::arith::Add for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Weight
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::AddAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div for bitcoin_units::Amount
+impl core::ops::arith::Div for bitcoin_units::SignedAmount
+impl core::ops::arith::Div for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<&bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<bitcoin_units::Amount> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for &i64
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem for bitcoin_units::Weight
+impl core::ops::arith::Rem<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeight> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtp> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Weight
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::SubAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::AmountDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::AmountEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::AmountDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::Sequence
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::SequenceDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::SequenceDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::SequenceEncoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::time::BlockTimeDecoder
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::time::BlockTimeDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::time::BlockTimeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::AmountDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::AmountEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::AmountDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::LockTimeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::LockTimeEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::SequenceDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::SequenceDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::SequenceEncoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::time::BlockTimeDecoder
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::time::BlockTimeDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::time::BlockTimeEncoder
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::Weight
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeightInterval
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtp
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtpInterval
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::LockTime
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::str::traits::FromStr for bitcoin_units::sequence::Sequence
+impl serde::ser::Serialize for bitcoin_units::BlockTime
+impl serde::ser::Serialize for bitcoin_units::Weight
+impl serde::ser::Serialize for bitcoin_units::block::BlockHeight
+impl serde::ser::Serialize for bitcoin_units::block::BlockHeightInterval
+impl serde::ser::Serialize for bitcoin_units::block::BlockMtp
+impl serde::ser::Serialize for bitcoin_units::block::BlockMtpInterval
+impl serde::ser::Serialize for bitcoin_units::locktime::absolute::LockTime
+impl serde::ser::Serialize for bitcoin_units::locktime::relative::LockTime
+impl serde::ser::Serialize for bitcoin_units::sequence::Sequence
+impl<'a, T: arbitrary::Arbitrary<'a>> arbitrary::Arbitrary<'a> for bitcoin_units::result::NumOpResult<T>
+impl<'a, T> core::ops::arith::Add<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::Amount
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::BlockTime
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::FeeRate
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::SignedAmount
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::Weight
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::amount::Denomination
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockHeight
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockHeightInterval
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockMtp
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockMtpInterval
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::Height
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::LockTime
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::MedianTimePast
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::result::MathOp
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::sequence::Sequence
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Weight> for bitcoin_units::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Amount> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::SignedAmount> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Rem<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::BlockTime
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::Weight
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeight
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeightInterval
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockMtp
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockMtpInterval
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::LockTime
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::LockTime
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::sequence::Sequence
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_units::result::NumOpResult<T>
+impl<T: core::marker::Copy> core::marker::Copy for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign + core::marker::Copy> core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign> core::ops::arith::AddAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign + core::marker::Copy> core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign> core::ops::arith::SubAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T> bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Freeze for bitcoin_units::result::NumOpResult<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_units::result::NumOpResult<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Sync for bitcoin_units::result::NumOpResult<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_units::result::NumOpResult<T> where T: core::marker::Unpin
+impl<T> core::ops::arith::Add for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_units::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::NumOpResult::Valid(T)
+pub bitcoin_units::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::result::MathOp::Add
+pub bitcoin_units::result::MathOp::Div
+pub bitcoin_units::result::MathOp::Mul
+pub bitcoin_units::result::MathOp::Neg
+pub bitcoin_units::result::MathOp::Rem
+pub bitcoin_units::result::MathOp::Sub
+pub bitcoin_units::result::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::result::NumOpResult::Valid(T)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::FeeRate::BROADCAST_MIN: Self
+pub const bitcoin_units::FeeRate::DUST: Self
+pub const bitcoin_units::FeeRate::MAX: Self
+pub const bitcoin_units::FeeRate::MIN: Self
+pub const bitcoin_units::FeeRate::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
+pub const bitcoin_units::Weight::MAX: Self
+pub const bitcoin_units::Weight::MAX_BLOCK: Self
+pub const bitcoin_units::Weight::MIN: Self
+pub const bitcoin_units::Weight::MIN_TRANSACTION: Self
+pub const bitcoin_units::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::Weight::ZERO: Self
+pub const bitcoin_units::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockHeightInterval::MAX: Self
+pub const bitcoin_units::block::BlockHeightInterval::MIN: Self
+pub const bitcoin_units::block::BlockHeightInterval::ZERO: Self
+pub const bitcoin_units::block::BlockMtp::MAX: Self
+pub const bitcoin_units::block::BlockMtp::MIN: Self
+pub const bitcoin_units::block::BlockMtp::ZERO: Self
+pub const bitcoin_units::block::BlockMtpInterval::MAX: Self
+pub const bitcoin_units::block::BlockMtpInterval::MIN: Self
+pub const bitcoin_units::block::BlockMtpInterval::ZERO: Self
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::absolute::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MAX: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MIN: Self
+pub const bitcoin_units::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::relative::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::ZERO: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_units::sequence::Sequence::FINAL: Self
+pub const bitcoin_units::sequence::Sequence::MAX: Self
+pub const bitcoin_units::sequence::Sequence::SIZE: usize
+pub const bitcoin_units::sequence::Sequence::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_floor(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_weight_ceil(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::div_by_weight_floor(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::from_btc_u16(whole_bitcoin: u16) -> Self
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::Amount::from_sat_u32(satoshi: u32) -> Self
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::BlockTime::from_u32(t: u32) -> Self
+pub const fn bitcoin_units::BlockTime::to_u32(self) -> u32
+pub const fn bitcoin_units::FeeRate::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kvb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kwu(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_vb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_sat_per_kvb(sat_kvb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_kwu(sat_kwu: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_vb(sat_vb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::mul_by_weight(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::FeeRate::to_fee(self, weight: bitcoin_units::Weight) -> bitcoin_units::Amount
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::SignedAmount::abs(self) -> Self
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::from_btc_i16(whole_bitcoin: i16) -> Self
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::SignedAmount::from_sat_i32(satoshi: i32) -> Self
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb_unwrap(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::Weight::mul_by_fee_rate(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::Weight::to_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_wu(self) -> u64
+pub const fn bitcoin_units::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::amount::AmountDecoder::new() -> Self
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockHeightDecoder::new() -> Self
+pub const fn bitcoin_units::block::BlockHeightInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeightInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtp::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtp::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtpInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_ceil(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_floor(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Height::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTimeDecoder::new() -> Self
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_512_second_intervals(self) -> u16
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_seconds(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_height(self) -> u16
+pub const fn bitcoin_units::sequence::Sequence::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::sequence::SequenceDecoder::new() -> Self
+pub const fn bitcoin_units::time::BlockTimeDecoder::new() -> Self
+pub enum bitcoin_units::NumOpResult<T>
+pub enum bitcoin_units::absolute::LockTime
+pub enum bitcoin_units::locktime::absolute::LockTime
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::locktime::relative::LockTime
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::IsSatisfiedByError
+pub enum bitcoin_units::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::LockTime
+pub enum bitcoin_units::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::result::NumOpResult<T>
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::decoder() -> Self::Decoder
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::encoder(&self) -> Self::Encoder
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::signed_sub(self, rhs: Self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::to_btc(self) -> f64
+pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::BlockTime::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::BlockTime::clone(&self) -> bitcoin_units::BlockTime
+pub fn bitcoin_units::BlockTime::cmp(&self, other: &bitcoin_units::BlockTime) -> core::cmp::Ordering
+pub fn bitcoin_units::BlockTime::decoder() -> Self::Decoder
+pub fn bitcoin_units::BlockTime::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::BlockTime::encoder(&self) -> Self::Encoder
+pub fn bitcoin_units::BlockTime::eq(&self, other: &bitcoin_units::BlockTime) -> bool
+pub fn bitcoin_units::BlockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::BlockTime::from(t: u32) -> Self
+pub fn bitcoin_units::BlockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::BlockTime::partial_cmp(&self, other: &bitcoin_units::BlockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::BlockTime::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::FeeRate::clone(&self) -> bitcoin_units::FeeRate
+pub fn bitcoin_units::FeeRate::cmp(&self, other: &bitcoin_units::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::eq(&self, other: &bitcoin_units::FeeRate) -> bool
+pub fn bitcoin_units::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fee_wu(self, weight: bitcoin_units::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::partial_cmp(&self, other: &bitcoin_units::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
+pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::Weight::clone(&self) -> bitcoin_units::Weight
+pub fn bitcoin_units::Weight::cmp(&self, other: &bitcoin_units::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::Weight::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::eq(&self, other: &bitcoin_units::Weight) -> bool
+pub fn bitcoin_units::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::partial_cmp(&self, other: &bitcoin_units::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::amount::AmountDecoder::default() -> Self
+pub fn bitcoin_units::amount::AmountDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_units::amount::AmountDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_units::amount::AmountDecoder::read_limit(&self) -> usize
+pub fn bitcoin_units::amount::AmountEncoder::advance(&mut self) -> bool
+pub fn bitcoin_units::amount::AmountEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_units::amount::Denomination::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::AmountDecoderError::clone(&self) -> bitcoin_units::amount::error::AmountDecoderError
+pub fn bitcoin_units::amount::error::AmountDecoderError::eq(&self, other: &bitcoin_units::amount::error::AmountDecoderError) -> bool
+pub fn bitcoin_units::amount::error::AmountDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::AmountDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::AmountDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::BadPositionError::clone(&self) -> bitcoin_units::amount::error::BadPositionError
+pub fn bitcoin_units::amount::error::BadPositionError::eq(&self, other: &bitcoin_units::amount::error::BadPositionError) -> bool
+pub fn bitcoin_units::amount::error::BadPositionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_btc::opt::serialize<A, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::amount::serde::as_btc::serialize<A, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::amount::serde::as_sat::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_sat::opt::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_sat::opt::serialize<A, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::amount::serde::as_sat::serialize<A, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::amount::serde::as_str::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_str::opt::deserialize<'d, A, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error> where A: core::convert::TryFrom<bitcoin_units::SignedAmount>, <A as core::convert::TryFrom<bitcoin_units::SignedAmount>>::Error: core::fmt::Display
+pub fn bitcoin_units::amount::serde::as_str::opt::serialize<A, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::amount::serde::as_str::serialize<A, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where A: core::convert::Into<bitcoin_units::SignedAmount> + core::marker::Copy
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::block::BlockHeight::checked_add(self, other: bitcoin_units::block::BlockHeightInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeight::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockHeightInterval>
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::decoder() -> Self::Decoder
+pub fn bitcoin_units::block::BlockHeight::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockHeight::encoder(&self) -> Self::Encoder
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightDecoder::default() -> Self
+pub fn bitcoin_units::block::BlockHeightDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_units::block::BlockHeightDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_units::block::BlockHeightDecoder::read_limit(&self) -> usize
+pub fn bitcoin_units::block::BlockHeightDecoderError::clone(&self) -> bitcoin_units::block::BlockHeightDecoderError
+pub fn bitcoin_units::block::BlockHeightDecoderError::eq(&self, other: &bitcoin_units::block::BlockHeightDecoderError) -> bool
+pub fn bitcoin_units::block::BlockHeightDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeightDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::block::BlockHeightDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::block::BlockHeightEncoder::advance(&mut self) -> bool
+pub fn bitcoin_units::block::BlockHeightEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::clone(&self) -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeightInterval::default() -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockHeightInterval::eq(&self, other: &bitcoin_units::block::BlockHeightInterval) -> bool
+pub fn bitcoin_units::block::BlockHeightInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeightInterval::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeightInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeightInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeightInterval::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::block::BlockMtp::checked_add(self, other: bitcoin_units::block::BlockMtpInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtp::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockMtpInterval>
+pub fn bitcoin_units::block::BlockMtp::clone(&self) -> bitcoin_units::block::BlockMtp
+pub fn bitcoin_units::block::BlockMtp::cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtp::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockMtp::eq(&self, other: &bitcoin_units::block::BlockMtp) -> bool
+pub fn bitcoin_units::block::BlockMtp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtp::from(h: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::block::BlockMtp::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtp::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtp::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtp::new(timestamps: [bitcoin_units::BlockTime; 11]) -> Self
+pub fn bitcoin_units::block::BlockMtp::partial_cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtp::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::clone(&self) -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtpInterval::default() -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::deserialize<D>(d: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockMtpInterval::eq(&self, other: &bitcoin_units::block::BlockMtpInterval) -> bool
+pub fn bitcoin_units::block::BlockMtpInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtpInterval::from(h: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtpInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtpInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtpInterval::serialize<S>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeHeightError
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::serde::OverflowError::clone(&self) -> bitcoin_units::fee_rate::serde::OverflowError
+pub fn bitcoin_units::fee_rate::serde::OverflowError::eq(&self, other: &bitcoin_units::fee_rate::serde::OverflowError) -> bool
+pub fn bitcoin_units::fee_rate::serde::OverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::serde::OverflowError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::locktime::absolute::Height::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::is_satisfied_by(self, height: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::locktime::absolute::LockTime::clone(&self) -> bitcoin_units::locktime::absolute::LockTime
+pub fn bitcoin_units::locktime::absolute::LockTime::decoder() -> Self::Decoder
+pub fn bitcoin_units::locktime::absolute::LockTime::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::absolute::LockTime::encoder(&self) -> Self::Encoder
+pub fn bitcoin_units::locktime::absolute::LockTime::eq(&self, other: &bitcoin_units::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_mtp(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by(self, height: bitcoin_units::locktime::absolute::Height, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_height(self, height: bitcoin_units::locktime::absolute::Height) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleHeightError>
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_time(self, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleTimeError>
+pub fn bitcoin_units::locktime::absolute::LockTime::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTimeDecoder::default() -> Self
+pub fn bitcoin_units::locktime::absolute::LockTimeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTimeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTimeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_units::locktime::absolute::LockTimeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTimeEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::clone(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::eq(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::is_satisfied_by(self, time: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::new(timestamps: [bitcoin_units::BlockTime; 11]) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(h: bitcoin_units::block::BlockMtp) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::error::ConversionError
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::incompatible(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::lock(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::incompatible(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::lock(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::LockTimeDecoderError::clone(&self) -> bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+pub fn bitcoin_units::locktime::absolute::error::LockTimeDecoderError::eq(&self, other: &bitcoin_units::locktime::absolute::error::LockTimeDecoderError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::LockTimeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::LockTimeDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::locktime::absolute::error::LockTimeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::relative::LockTime::clone(&self) -> bitcoin_units::locktime::relative::LockTime
+pub fn bitcoin_units::locktime::relative::LockTime::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::relative::LockTime::eq(&self, other: &bitcoin_units::locktime::relative::LockTime) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::from_sequence(n: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by_sequence(self, other: bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by(self, chain_tip_height: bitcoin_units::block::BlockHeight, chain_tip_mtp: bitcoin_units::block::BlockMtp, utxo_mined_at_height: bitcoin_units::block::BlockHeight, utxo_mined_at_mtp: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_height(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_time(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::relative::LockTime::to_sequence(self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::locktime::relative::LockTime::try_from(seq: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::clone(&self) -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::default() -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::eq(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::clone(&self) -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::default() -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::eq(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidHeightError>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(h: bitcoin_units::block::BlockHeightInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::DisabledLockTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidHeightError
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidTimeError
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::error::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::error::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::clone(&self) -> bitcoin_units::parse_int::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::eq(&self, other: &bitcoin_units::parse_int::ParseIntError) -> bool
+pub fn bitcoin_units::parse_int::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::ParseIntError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse_int::PrefixedHexError::clone(&self) -> bitcoin_units::parse_int::PrefixedHexError
+pub fn bitcoin_units::parse_int::PrefixedHexError::eq(&self, other: &bitcoin_units::parse_int::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::PrefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse_int::UnprefixedHexError::clone(&self) -> bitcoin_units::parse_int::UnprefixedHexError
+pub fn bitcoin_units::parse_int::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse_int::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse_int::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::int_from_box<T: bitcoin_units::parse_int::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::int_from_str<T: bitcoin_units::parse_int::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::int_from_string<T: bitcoin_units::parse_int::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::result::MathOp::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::result::MathOp::clone(&self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::MathOp::eq(&self, other: &bitcoin_units::result::MathOp) -> bool
+pub fn bitcoin_units::result::MathOp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::MathOp::is_addition(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_multiplication(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_negation(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_overflow(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_subtraction(self) -> bool
+pub fn bitcoin_units::result::NumOpError::clone(&self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpError::eq(&self, other: &bitcoin_units::result::NumOpError) -> bool
+pub fn bitcoin_units::result::NumOpError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpError::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::NumOpError::is_overflow(self) -> bool
+pub fn bitcoin_units::result::NumOpError::operation(self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::and_then<F>(self, op: F) -> Self where F: core::ops::function::FnOnce(T) -> Self
+pub fn bitcoin_units::result::NumOpResult<T>::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::result::NumOpResult<T>::clone(&self) -> bitcoin_units::result::NumOpResult<T>
+pub fn bitcoin_units::result::NumOpResult<T>::eq(&self, other: &bitcoin_units::result::NumOpResult<T>) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::expect(self, msg: &str) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpResult<T>::into_result(self) -> core::result::Result<T, bitcoin_units::result::NumOpError>
+pub fn bitcoin_units::result::NumOpResult<T>::is_error(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::is_valid(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, op: F) -> bitcoin_units::result::NumOpResult<U>
+pub fn bitcoin_units::result::NumOpResult<T>::ok(self) -> core::option::Option<T>
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap(self) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_err(self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or(self, default: T) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or_else<F>(self, f: F) -> T where F: core::ops::function::FnOnce() -> T
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: &bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: &bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::sequence::Sequence::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::sequence::Sequence::clone(&self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::sequence::Sequence::cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_units::sequence::Sequence::decoder() -> Self::Decoder
+pub fn bitcoin_units::sequence::Sequence::default() -> Self
+pub fn bitcoin_units::sequence::Sequence::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::sequence::Sequence::enables_absolute_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::encoder(&self) -> Self::Encoder
+pub fn bitcoin_units::sequence::Sequence::eq(&self, other: &bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::sequence::Sequence::from(lt: bitcoin_units::locktime::relative::LockTime) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::sequence::Sequence::is_final(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_height_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_rbf(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_relative_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_time_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::partial_cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::sequence::Sequence::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::sequence::Sequence::to_hex(self) -> alloc::string::String
+pub fn bitcoin_units::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_units::locktime::relative::LockTime>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::sequence::SequenceDecoder::default() -> Self
+pub fn bitcoin_units::sequence::SequenceDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_units::sequence::SequenceDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_units::sequence::SequenceDecoder::read_limit(&self) -> usize
+pub fn bitcoin_units::sequence::SequenceDecoderError::clone(&self) -> bitcoin_units::sequence::SequenceDecoderError
+pub fn bitcoin_units::sequence::SequenceDecoderError::eq(&self, other: &bitcoin_units::sequence::SequenceDecoderError) -> bool
+pub fn bitcoin_units::sequence::SequenceDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::sequence::SequenceDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::sequence::SequenceDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::sequence::SequenceEncoder::advance(&mut self) -> bool
+pub fn bitcoin_units::sequence::SequenceEncoder::current_chunk(&self) -> &[u8]
+pub fn bitcoin_units::time::BlockTimeDecoder::default() -> Self
+pub fn bitcoin_units::time::BlockTimeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
+pub fn bitcoin_units::time::BlockTimeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error>
+pub fn bitcoin_units::time::BlockTimeDecoder::read_limit(&self) -> usize
+pub fn bitcoin_units::time::BlockTimeDecoderError::clone(&self) -> bitcoin_units::time::BlockTimeDecoderError
+pub fn bitcoin_units::time::BlockTimeDecoderError::eq(&self, other: &bitcoin_units::time::BlockTimeDecoderError) -> bool
+pub fn bitcoin_units::time::BlockTimeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::time::BlockTimeDecoderError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::time::BlockTimeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::time::BlockTimeEncoder::advance(&mut self) -> bool
+pub fn bitcoin_units::time::BlockTimeEncoder::current_chunk(&self) -> &[u8]
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeightInterval) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtp) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtpInterval) -> Self
+pub fn u32::from(sequence: bitcoin_units::sequence::Sequence) -> Self
+pub fn u32::from(t: bitcoin_units::BlockTime) -> Self
+pub fn u64::from(value: bitcoin_units::Weight) -> Self
+pub fn u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub mod bitcoin_units
+pub mod bitcoin_units::absolute
+pub mod bitcoin_units::absolute::error
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::amount::serde
+pub mod bitcoin_units::amount::serde::as_btc
+pub mod bitcoin_units::amount::serde::as_btc::opt
+pub mod bitcoin_units::amount::serde::as_sat
+pub mod bitcoin_units::amount::serde::as_sat::opt
+pub mod bitcoin_units::amount::serde::as_str
+pub mod bitcoin_units::amount::serde::as_str::opt
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::fee_rate::serde
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu_floor::opt
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::absolute::error
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::locktime::relative::error
+pub mod bitcoin_units::parse_int
+pub mod bitcoin_units::relative
+pub mod bitcoin_units::relative::error
+pub mod bitcoin_units::result
+pub mod bitcoin_units::sequence
+pub mod bitcoin_units::time
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(_)
+pub struct bitcoin_units::BlockHeightInterval(_)
+pub struct bitcoin_units::BlockMtp(_)
+pub struct bitcoin_units::BlockMtpInterval(_)
+pub struct bitcoin_units::BlockTime(_)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::Sequence(pub u32)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::absolute::Height(_)
+pub struct bitcoin_units::absolute::IncompatibleHeightError
+pub struct bitcoin_units::absolute::IncompatibleTimeError
+pub struct bitcoin_units::absolute::LockTimeDecoder(_)
+pub struct bitcoin_units::absolute::LockTimeDecoderError(_)
+pub struct bitcoin_units::absolute::LockTimeEncoder(_)
+pub struct bitcoin_units::absolute::MedianTimePast(_)
+pub struct bitcoin_units::absolute::ParseHeightError(_)
+pub struct bitcoin_units::absolute::ParseTimeError(_)
+pub struct bitcoin_units::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::absolute::error::LockTimeDecoderError(_)
+pub struct bitcoin_units::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::AmountDecoder(_)
+pub struct bitcoin_units::amount::AmountDecoderError(_)
+pub struct bitcoin_units::amount::AmountEncoder(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::error::AmountDecoderError(_)
+pub struct bitcoin_units::amount::error::BadPositionError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(_)
+pub struct bitcoin_units::block::BlockHeightDecoder(_)
+pub struct bitcoin_units::block::BlockHeightDecoderError(_)
+pub struct bitcoin_units::block::BlockHeightEncoder(_)
+pub struct bitcoin_units::block::BlockHeightInterval(_)
+pub struct bitcoin_units::block::BlockMtp(_)
+pub struct bitcoin_units::block::BlockMtpInterval(_)
+pub struct bitcoin_units::block::TooBigForRelativeHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::LockTimeDecoder(_)
+pub struct bitcoin_units::locktime::absolute::LockTimeDecoderError(_)
+pub struct bitcoin_units::locktime::absolute::LockTimeEncoder(_)
+pub struct bitcoin_units::locktime::absolute::MedianTimePast(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::error::LockTimeDecoderError(_)
+pub struct bitcoin_units::locktime::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::locktime::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::locktime::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::locktime::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::error::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::error::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::error::TimeOverflowError
+pub struct bitcoin_units::parse_int::PrefixedHexError(_)
+pub struct bitcoin_units::parse_int::UnprefixedHexError(_)
+pub struct bitcoin_units::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::InvalidHeightError
+pub struct bitcoin_units::relative::InvalidTimeError
+pub struct bitcoin_units::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::relative::TimeOverflowError
+pub struct bitcoin_units::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::error::InvalidHeightError
+pub struct bitcoin_units::relative::error::InvalidTimeError
+pub struct bitcoin_units::relative::error::TimeOverflowError
+pub struct bitcoin_units::sequence::Sequence(pub u32)
+pub struct bitcoin_units::sequence::SequenceDecoder(_)
+pub struct bitcoin_units::sequence::SequenceDecoderError(_)
+pub struct bitcoin_units::sequence::SequenceEncoder(_)
+pub struct bitcoin_units::time::BlockTime(_)
+pub struct bitcoin_units::time::BlockTimeDecoder(_)
+pub struct bitcoin_units::time::BlockTimeDecoderError(_)
+pub struct bitcoin_units::time::BlockTimeEncoder(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::parse_int::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse_int::sealed::Sealed
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Decoder = bitcoin_units::amount::AmountDecoder
+pub type bitcoin_units::Amount::Encoder<'e> = bitcoin_units::amount::AmountEncoder
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<u64>
+pub type bitcoin_units::BlockTime::Decoder = bitcoin_units::time::BlockTimeDecoder
+pub type bitcoin_units::BlockTime::Encoder<'e> = bitcoin_units::time::BlockTimeEncoder
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::FeeRate
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<i64>
+pub type bitcoin_units::Weight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Weight::Output = bitcoin_units::Weight
+pub type bitcoin_units::Weight::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Weight::Output = u64
+pub type bitcoin_units::amount::AmountDecoder::Error = bitcoin_units::amount::error::AmountDecoderError
+pub type bitcoin_units::amount::AmountDecoder::Output = bitcoin_units::Amount
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Decoder = bitcoin_units::block::BlockHeightDecoder
+pub type bitcoin_units::block::BlockHeight::Encoder<'e> = bitcoin_units::block::BlockHeightEncoder
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockHeightDecoder::Error = bitcoin_units::block::BlockHeightDecoderError
+pub type bitcoin_units::block::BlockHeightDecoder::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeightInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockMtp::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtp
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::block::BlockMtpInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::LockTime::Decoder = bitcoin_units::locktime::absolute::LockTimeDecoder
+pub type bitcoin_units::locktime::absolute::LockTime::Encoder<'e> = bitcoin_units::locktime::absolute::LockTimeEncoder
+pub type bitcoin_units::locktime::absolute::LockTime::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::LockTime::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::LockTimeDecoder::Error = bitcoin_units::locktime::absolute::error::LockTimeDecoderError
+pub type bitcoin_units::locktime::absolute::LockTimeDecoder::Output = bitcoin_units::locktime::absolute::LockTime
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Err = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::relative::LockTime::Error = bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::block::TooBigForRelativeHeightError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = bitcoin_units::result::NumOpResult<T>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::sequence::Sequence::Decoder = bitcoin_units::sequence::SequenceDecoder
+pub type bitcoin_units::sequence::Sequence::Encoder<'e> = bitcoin_units::sequence::SequenceEncoder
+pub type bitcoin_units::sequence::Sequence::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::sequence::Sequence::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::sequence::SequenceDecoder::Error = bitcoin_units::sequence::SequenceDecoderError
+pub type bitcoin_units::sequence::SequenceDecoder::Output = bitcoin_units::sequence::Sequence
+pub type bitcoin_units::time::BlockTimeDecoder::Error = bitcoin_units::time::BlockTimeDecoderError
+pub type bitcoin_units::time::BlockTimeDecoder::Output = bitcoin_units::BlockTime
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type i64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type u64::Output = bitcoin_units::Weight
+pub type u64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
new file mode 100644
index 0000000000..eeb4cec3b6
--- /dev/null
+++ b/api/units/alloc-only.txt
@@ -0,0 +1,2423 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::result::MathOp
+#[non_exhaustive] pub struct bitcoin_units::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse_int::ParseIntError
+#[non_exhaustive] pub struct bitcoin_units::result::NumOpError(_)
+impl bitcoin_units::Amount
+impl bitcoin_units::BlockTime
+impl bitcoin_units::FeeRate
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::Weight
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockHeightInterval
+impl bitcoin_units::block::BlockMtp
+impl bitcoin_units::block::BlockMtpInterval
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::LockTime
+impl bitcoin_units::locktime::absolute::MedianTimePast
+impl bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl bitcoin_units::locktime::relative::LockTime
+impl bitcoin_units::locktime::relative::NumberOf512Seconds
+impl bitcoin_units::locktime::relative::NumberOfBlocks
+impl bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl bitcoin_units::parse_int::Integer for i128
+impl bitcoin_units::parse_int::Integer for i16
+impl bitcoin_units::parse_int::Integer for i32
+impl bitcoin_units::parse_int::Integer for i64
+impl bitcoin_units::parse_int::Integer for i8
+impl bitcoin_units::parse_int::Integer for u128
+impl bitcoin_units::parse_int::Integer for u16
+impl bitcoin_units::parse_int::Integer for u32
+impl bitcoin_units::parse_int::Integer for u64
+impl bitcoin_units::parse_int::Integer for u8
+impl bitcoin_units::result::MathOp
+impl bitcoin_units::result::NumOpError
+impl bitcoin_units::sequence::Sequence
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::BlockTime
+impl core::clone::Clone for bitcoin_units::FeeRate
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::Weight
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::BadPositionError
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockHeightInterval
+impl core::clone::Clone for bitcoin_units::block::BlockMtp
+impl core::clone::Clone for bitcoin_units::block::BlockMtpInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse_int::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse_int::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse_int::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::result::MathOp
+impl core::clone::Clone for bitcoin_units::result::NumOpError
+impl core::clone::Clone for bitcoin_units::sequence::Sequence
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::BlockTime
+impl core::cmp::Eq for bitcoin_units::FeeRate
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::Weight
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Eq for bitcoin_units::block::BlockMtp
+impl core::cmp::Eq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::result::MathOp
+impl core::cmp::Eq for bitcoin_units::result::NumOpError
+impl core::cmp::Eq for bitcoin_units::sequence::Sequence
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::BlockTime
+impl core::cmp::Ord for bitcoin_units::FeeRate
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::Weight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Ord for bitcoin_units::block::BlockMtp
+impl core::cmp::Ord for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Ord for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::BlockTime
+impl core::cmp::PartialEq for bitcoin_units::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::Weight
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::result::MathOp
+impl core::cmp::PartialEq for bitcoin_units::result::NumOpError
+impl core::cmp::PartialEq for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::BlockTime
+impl core::cmp::PartialOrd for bitcoin_units::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::Weight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialOrd for bitcoin_units::sequence::Sequence
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse_int::ParseIntError
+impl core::convert::From<&bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<&bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<bitcoin_units::BlockTime> for u32
+impl core::convert::From<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Weight> for u64
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockHeightInterval> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtp> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtpInterval> for u32
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::block::BlockMtp
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::LockTime> for bitcoin_units::sequence::Sequence
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::sequence::Sequence> for u32
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::From<u32> for bitcoin_units::BlockTime
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtp
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::Weight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<&str> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::Weight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::Weight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<bitcoin_units::block::BlockMtp> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<bitcoin_units::sequence::Sequence> for bitcoin_units::locktime::relative::LockTime
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::block::BlockHeightInterval
+impl core::default::Default for bitcoin_units::block::BlockMtpInterval
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::default::Default for bitcoin_units::sequence::Sequence
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::BlockTime
+impl core::fmt::Debug for bitcoin_units::FeeRate
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::Weight
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Debug for bitcoin_units::block::BlockMtp
+impl core::fmt::Debug for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::result::MathOp
+impl core::fmt::Debug for bitcoin_units::result::NumOpError
+impl core::fmt::Debug for bitcoin_units::sequence::Sequence
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::Weight
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Display for bitcoin_units::block::BlockMtp
+impl core::fmt::Display for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::result::MathOp
+impl core::fmt::Display for bitcoin_units::result::NumOpError
+impl core::fmt::Display for bitcoin_units::sequence::Sequence
+impl core::fmt::LowerHex for bitcoin_units::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_units::sequence::Sequence
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::BlockTime
+impl core::hash::Hash for bitcoin_units::FeeRate
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::Weight
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockHeightInterval
+impl core::hash::Hash for bitcoin_units::block::BlockMtp
+impl core::hash::Hash for bitcoin_units::block::BlockMtpInterval
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::hash::Hash for bitcoin_units::locktime::relative::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::hash::Hash for bitcoin_units::sequence::Sequence
+impl core::iter::traits::accum::Sum for bitcoin_units::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockHeightInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockMtpInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::BlockTime
+impl core::marker::Copy for bitcoin_units::FeeRate
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::Weight
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Copy for bitcoin_units::block::BlockMtp
+impl core::marker::Copy for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Copy for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Copy for bitcoin_units::result::MathOp
+impl core::marker::Copy for bitcoin_units::result::NumOpError
+impl core::marker::Copy for bitcoin_units::sequence::Sequence
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::BlockTime
+impl core::marker::Freeze for bitcoin_units::FeeRate
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::Weight
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Freeze for bitcoin_units::block::BlockMtp
+impl core::marker::Freeze for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::result::MathOp
+impl core::marker::Freeze for bitcoin_units::result::NumOpError
+impl core::marker::Freeze for bitcoin_units::sequence::Sequence
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::BlockTime
+impl core::marker::Send for bitcoin_units::FeeRate
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::Weight
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Send for bitcoin_units::block::BlockMtp
+impl core::marker::Send for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Send for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Send for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::result::MathOp
+impl core::marker::Send for bitcoin_units::result::NumOpError
+impl core::marker::Send for bitcoin_units::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::BlockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtp
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::result::MathOp
+impl core::marker::StructuralPartialEq for bitcoin_units::result::NumOpError
+impl core::marker::StructuralPartialEq for bitcoin_units::sequence::Sequence
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::BlockTime
+impl core::marker::Sync for bitcoin_units::FeeRate
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::Weight
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Sync for bitcoin_units::block::BlockMtp
+impl core::marker::Sync for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::result::MathOp
+impl core::marker::Sync for bitcoin_units::result::NumOpError
+impl core::marker::Sync for bitcoin_units::sequence::Sequence
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::BlockTime
+impl core::marker::Unpin for bitcoin_units::FeeRate
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::Weight
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Unpin for bitcoin_units::block::BlockMtp
+impl core::marker::Unpin for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::result::MathOp
+impl core::marker::Unpin for bitcoin_units::result::NumOpError
+impl core::marker::Unpin for bitcoin_units::sequence::Sequence
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::FeeRate
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::Weight
+impl core::ops::arith::Add for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Weight
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::AddAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div for bitcoin_units::Amount
+impl core::ops::arith::Div for bitcoin_units::SignedAmount
+impl core::ops::arith::Div for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<&bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<bitcoin_units::Amount> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for &i64
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem for bitcoin_units::Weight
+impl core::ops::arith::Rem<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeight> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtp> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Weight
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::SubAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::Sequence
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::Weight
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeightInterval
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtp
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtpInterval
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::LockTime
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::str::traits::FromStr for bitcoin_units::sequence::Sequence
+impl<'a, T> core::ops::arith::Add<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Weight> for bitcoin_units::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Amount> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::SignedAmount> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Rem<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_units::result::NumOpResult<T>
+impl<T: core::marker::Copy> core::marker::Copy for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign + core::marker::Copy> core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign> core::ops::arith::AddAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign + core::marker::Copy> core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign> core::ops::arith::SubAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T> bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Freeze for bitcoin_units::result::NumOpResult<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_units::result::NumOpResult<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Sync for bitcoin_units::result::NumOpResult<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_units::result::NumOpResult<T> where T: core::marker::Unpin
+impl<T> core::ops::arith::Add for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_units::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::NumOpResult::Valid(T)
+pub bitcoin_units::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::result::MathOp::Add
+pub bitcoin_units::result::MathOp::Div
+pub bitcoin_units::result::MathOp::Mul
+pub bitcoin_units::result::MathOp::Neg
+pub bitcoin_units::result::MathOp::Rem
+pub bitcoin_units::result::MathOp::Sub
+pub bitcoin_units::result::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::result::NumOpResult::Valid(T)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::FeeRate::BROADCAST_MIN: Self
+pub const bitcoin_units::FeeRate::DUST: Self
+pub const bitcoin_units::FeeRate::MAX: Self
+pub const bitcoin_units::FeeRate::MIN: Self
+pub const bitcoin_units::FeeRate::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
+pub const bitcoin_units::Weight::MAX: Self
+pub const bitcoin_units::Weight::MAX_BLOCK: Self
+pub const bitcoin_units::Weight::MIN: Self
+pub const bitcoin_units::Weight::MIN_TRANSACTION: Self
+pub const bitcoin_units::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::Weight::ZERO: Self
+pub const bitcoin_units::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockHeightInterval::MAX: Self
+pub const bitcoin_units::block::BlockHeightInterval::MIN: Self
+pub const bitcoin_units::block::BlockHeightInterval::ZERO: Self
+pub const bitcoin_units::block::BlockMtp::MAX: Self
+pub const bitcoin_units::block::BlockMtp::MIN: Self
+pub const bitcoin_units::block::BlockMtp::ZERO: Self
+pub const bitcoin_units::block::BlockMtpInterval::MAX: Self
+pub const bitcoin_units::block::BlockMtpInterval::MIN: Self
+pub const bitcoin_units::block::BlockMtpInterval::ZERO: Self
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::absolute::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MAX: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MIN: Self
+pub const bitcoin_units::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::relative::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::ZERO: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_units::sequence::Sequence::FINAL: Self
+pub const bitcoin_units::sequence::Sequence::MAX: Self
+pub const bitcoin_units::sequence::Sequence::SIZE: usize
+pub const bitcoin_units::sequence::Sequence::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_floor(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_weight_ceil(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::div_by_weight_floor(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::from_btc_u16(whole_bitcoin: u16) -> Self
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::Amount::from_sat_u32(satoshi: u32) -> Self
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::BlockTime::from_u32(t: u32) -> Self
+pub const fn bitcoin_units::BlockTime::to_u32(self) -> u32
+pub const fn bitcoin_units::FeeRate::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kvb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kwu(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_vb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_sat_per_kvb(sat_kvb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_kwu(sat_kwu: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_vb(sat_vb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::mul_by_weight(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::FeeRate::to_fee(self, weight: bitcoin_units::Weight) -> bitcoin_units::Amount
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::SignedAmount::abs(self) -> Self
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::from_btc_i16(whole_bitcoin: i16) -> Self
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::SignedAmount::from_sat_i32(satoshi: i32) -> Self
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb_unwrap(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::Weight::mul_by_fee_rate(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::Weight::to_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_wu(self) -> u64
+pub const fn bitcoin_units::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockHeightInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeightInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtp::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtp::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtpInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_ceil(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_floor(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Height::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_512_second_intervals(self) -> u16
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_seconds(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_height(self) -> u16
+pub const fn bitcoin_units::sequence::Sequence::to_consensus_u32(self) -> u32
+pub enum bitcoin_units::NumOpResult<T>
+pub enum bitcoin_units::absolute::LockTime
+pub enum bitcoin_units::locktime::absolute::LockTime
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::locktime::relative::LockTime
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::IsSatisfiedByError
+pub enum bitcoin_units::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::LockTime
+pub enum bitcoin_units::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::result::NumOpResult<T>
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::signed_sub(self, rhs: Self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::to_btc(self) -> f64
+pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::BlockTime::clone(&self) -> bitcoin_units::BlockTime
+pub fn bitcoin_units::BlockTime::cmp(&self, other: &bitcoin_units::BlockTime) -> core::cmp::Ordering
+pub fn bitcoin_units::BlockTime::eq(&self, other: &bitcoin_units::BlockTime) -> bool
+pub fn bitcoin_units::BlockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::BlockTime::from(t: u32) -> Self
+pub fn bitcoin_units::BlockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::BlockTime::partial_cmp(&self, other: &bitcoin_units::BlockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::clone(&self) -> bitcoin_units::FeeRate
+pub fn bitcoin_units::FeeRate::cmp(&self, other: &bitcoin_units::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::eq(&self, other: &bitcoin_units::FeeRate) -> bool
+pub fn bitcoin_units::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fee_wu(self, weight: bitcoin_units::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::partial_cmp(&self, other: &bitcoin_units::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
+pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::clone(&self) -> bitcoin_units::Weight
+pub fn bitcoin_units::Weight::cmp(&self, other: &bitcoin_units::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::eq(&self, other: &bitcoin_units::Weight) -> bool
+pub fn bitcoin_units::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::partial_cmp(&self, other: &bitcoin_units::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::BadPositionError::clone(&self) -> bitcoin_units::amount::error::BadPositionError
+pub fn bitcoin_units::amount::error::BadPositionError::eq(&self, other: &bitcoin_units::amount::error::BadPositionError) -> bool
+pub fn bitcoin_units::amount::error::BadPositionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::checked_add(self, other: bitcoin_units::block::BlockHeightInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeight::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockHeightInterval>
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::clone(&self) -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeightInterval::default() -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::eq(&self, other: &bitcoin_units::block::BlockHeightInterval) -> bool
+pub fn bitcoin_units::block::BlockHeightInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeightInterval::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeightInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeightInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::checked_add(self, other: bitcoin_units::block::BlockMtpInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtp::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockMtpInterval>
+pub fn bitcoin_units::block::BlockMtp::clone(&self) -> bitcoin_units::block::BlockMtp
+pub fn bitcoin_units::block::BlockMtp::cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtp::eq(&self, other: &bitcoin_units::block::BlockMtp) -> bool
+pub fn bitcoin_units::block::BlockMtp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtp::from(h: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::block::BlockMtp::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtp::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtp::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtp::new(timestamps: [bitcoin_units::BlockTime; 11]) -> Self
+pub fn bitcoin_units::block::BlockMtp::partial_cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::clone(&self) -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtpInterval::default() -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::eq(&self, other: &bitcoin_units::block::BlockMtpInterval) -> bool
+pub fn bitcoin_units::block::BlockMtpInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtpInterval::from(h: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtpInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtpInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeHeightError
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::is_satisfied_by(self, height: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::clone(&self) -> bitcoin_units::locktime::absolute::LockTime
+pub fn bitcoin_units::locktime::absolute::LockTime::eq(&self, other: &bitcoin_units::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_mtp(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by(self, height: bitcoin_units::locktime::absolute::Height, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_height(self, height: bitcoin_units::locktime::absolute::Height) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleHeightError>
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_time(self, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleTimeError>
+pub fn bitcoin_units::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::clone(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::eq(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::is_satisfied_by(self, time: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::new(timestamps: [bitcoin_units::BlockTime; 11]) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(h: bitcoin_units::block::BlockMtp) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::error::ConversionError
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::incompatible(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::lock(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::incompatible(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::lock(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::LockTime::clone(&self) -> bitcoin_units::locktime::relative::LockTime
+pub fn bitcoin_units::locktime::relative::LockTime::eq(&self, other: &bitcoin_units::locktime::relative::LockTime) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::from_sequence(n: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by_sequence(self, other: bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by(self, chain_tip_height: bitcoin_units::block::BlockHeight, chain_tip_mtp: bitcoin_units::block::BlockMtp, utxo_mined_at_height: bitcoin_units::block::BlockHeight, utxo_mined_at_mtp: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_height(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_time(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::relative::LockTime::to_sequence(self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::locktime::relative::LockTime::try_from(seq: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::clone(&self) -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::default() -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::eq(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::clone(&self) -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::default() -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::eq(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidHeightError>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(h: bitcoin_units::block::BlockHeightInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::DisabledLockTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidHeightError
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidTimeError
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::error::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::error::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::clone(&self) -> bitcoin_units::parse_int::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::eq(&self, other: &bitcoin_units::parse_int::ParseIntError) -> bool
+pub fn bitcoin_units::parse_int::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::PrefixedHexError::clone(&self) -> bitcoin_units::parse_int::PrefixedHexError
+pub fn bitcoin_units::parse_int::PrefixedHexError::eq(&self, other: &bitcoin_units::parse_int::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::clone(&self) -> bitcoin_units::parse_int::UnprefixedHexError
+pub fn bitcoin_units::parse_int::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse_int::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::int_from_box<T: bitcoin_units::parse_int::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::int_from_str<T: bitcoin_units::parse_int::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::int_from_string<T: bitcoin_units::parse_int::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::result::MathOp::clone(&self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::MathOp::eq(&self, other: &bitcoin_units::result::MathOp) -> bool
+pub fn bitcoin_units::result::MathOp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::MathOp::is_addition(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_multiplication(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_negation(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_overflow(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_subtraction(self) -> bool
+pub fn bitcoin_units::result::NumOpError::clone(&self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpError::eq(&self, other: &bitcoin_units::result::NumOpError) -> bool
+pub fn bitcoin_units::result::NumOpError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpError::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::NumOpError::is_overflow(self) -> bool
+pub fn bitcoin_units::result::NumOpError::operation(self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::and_then<F>(self, op: F) -> Self where F: core::ops::function::FnOnce(T) -> Self
+pub fn bitcoin_units::result::NumOpResult<T>::clone(&self) -> bitcoin_units::result::NumOpResult<T>
+pub fn bitcoin_units::result::NumOpResult<T>::eq(&self, other: &bitcoin_units::result::NumOpResult<T>) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::expect(self, msg: &str) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpResult<T>::into_result(self) -> core::result::Result<T, bitcoin_units::result::NumOpError>
+pub fn bitcoin_units::result::NumOpResult<T>::is_error(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::is_valid(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, op: F) -> bitcoin_units::result::NumOpResult<U>
+pub fn bitcoin_units::result::NumOpResult<T>::ok(self) -> core::option::Option<T>
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap(self) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_err(self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or(self, default: T) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or_else<F>(self, f: F) -> T where F: core::ops::function::FnOnce() -> T
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: &bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: &bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::sequence::Sequence::clone(&self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::sequence::Sequence::cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_units::sequence::Sequence::default() -> Self
+pub fn bitcoin_units::sequence::Sequence::enables_absolute_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::eq(&self, other: &bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::sequence::Sequence::from(lt: bitcoin_units::locktime::relative::LockTime) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::sequence::Sequence::is_final(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_height_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_rbf(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_relative_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_time_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::partial_cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::sequence::Sequence::to_hex(self) -> alloc::string::String
+pub fn bitcoin_units::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_units::locktime::relative::LockTime>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeightInterval) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtp) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtpInterval) -> Self
+pub fn u32::from(sequence: bitcoin_units::sequence::Sequence) -> Self
+pub fn u32::from(t: bitcoin_units::BlockTime) -> Self
+pub fn u64::from(value: bitcoin_units::Weight) -> Self
+pub fn u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub mod bitcoin_units
+pub mod bitcoin_units::absolute
+pub mod bitcoin_units::absolute::error
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::absolute::error
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::locktime::relative::error
+pub mod bitcoin_units::parse_int
+pub mod bitcoin_units::relative
+pub mod bitcoin_units::relative::error
+pub mod bitcoin_units::result
+pub mod bitcoin_units::sequence
+pub mod bitcoin_units::time
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(_)
+pub struct bitcoin_units::BlockHeightInterval(_)
+pub struct bitcoin_units::BlockMtp(_)
+pub struct bitcoin_units::BlockMtpInterval(_)
+pub struct bitcoin_units::BlockTime(_)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::Sequence(pub u32)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::absolute::Height(_)
+pub struct bitcoin_units::absolute::IncompatibleHeightError
+pub struct bitcoin_units::absolute::IncompatibleTimeError
+pub struct bitcoin_units::absolute::MedianTimePast(_)
+pub struct bitcoin_units::absolute::ParseHeightError(_)
+pub struct bitcoin_units::absolute::ParseTimeError(_)
+pub struct bitcoin_units::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::error::BadPositionError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(_)
+pub struct bitcoin_units::block::BlockHeightInterval(_)
+pub struct bitcoin_units::block::BlockMtp(_)
+pub struct bitcoin_units::block::BlockMtpInterval(_)
+pub struct bitcoin_units::block::TooBigForRelativeHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::MedianTimePast(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::locktime::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::locktime::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::locktime::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::error::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::error::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::error::TimeOverflowError
+pub struct bitcoin_units::parse_int::PrefixedHexError(_)
+pub struct bitcoin_units::parse_int::UnprefixedHexError(_)
+pub struct bitcoin_units::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::InvalidHeightError
+pub struct bitcoin_units::relative::InvalidTimeError
+pub struct bitcoin_units::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::relative::TimeOverflowError
+pub struct bitcoin_units::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::error::InvalidHeightError
+pub struct bitcoin_units::relative::error::InvalidTimeError
+pub struct bitcoin_units::relative::error::TimeOverflowError
+pub struct bitcoin_units::sequence::Sequence(pub u32)
+pub struct bitcoin_units::time::BlockTime(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::parse_int::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse_int::sealed::Sealed
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<u64>
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::FeeRate
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<i64>
+pub type bitcoin_units::Weight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Weight::Output = bitcoin_units::Weight
+pub type bitcoin_units::Weight::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Weight::Output = u64
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockHeightInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockMtp::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtp
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::block::BlockMtpInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::LockTime::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::LockTime::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Err = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::relative::LockTime::Error = bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::block::TooBigForRelativeHeightError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = bitcoin_units::result::NumOpResult<T>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::sequence::Sequence::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::sequence::Sequence::Error = bitcoin_units::parse_int::ParseIntError
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type i64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type u64::Output = bitcoin_units::Weight
+pub type u64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
new file mode 100644
index 0000000000..8c0c21e5f6
--- /dev/null
+++ b/api/units/no-features.txt
@@ -0,0 +1,2358 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::result::MathOp
+#[non_exhaustive] pub struct bitcoin_units::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::error::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse_int::ParseIntError
+#[non_exhaustive] pub struct bitcoin_units::result::NumOpError(_)
+impl bitcoin_units::Amount
+impl bitcoin_units::BlockTime
+impl bitcoin_units::FeeRate
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::Weight
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockHeightInterval
+impl bitcoin_units::block::BlockMtp
+impl bitcoin_units::block::BlockMtpInterval
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::LockTime
+impl bitcoin_units::locktime::absolute::MedianTimePast
+impl bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl bitcoin_units::locktime::relative::LockTime
+impl bitcoin_units::locktime::relative::NumberOf512Seconds
+impl bitcoin_units::locktime::relative::NumberOfBlocks
+impl bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl bitcoin_units::parse_int::Integer for i128
+impl bitcoin_units::parse_int::Integer for i16
+impl bitcoin_units::parse_int::Integer for i32
+impl bitcoin_units::parse_int::Integer for i64
+impl bitcoin_units::parse_int::Integer for i8
+impl bitcoin_units::parse_int::Integer for u128
+impl bitcoin_units::parse_int::Integer for u16
+impl bitcoin_units::parse_int::Integer for u32
+impl bitcoin_units::parse_int::Integer for u64
+impl bitcoin_units::parse_int::Integer for u8
+impl bitcoin_units::result::MathOp
+impl bitcoin_units::result::NumOpError
+impl bitcoin_units::sequence::Sequence
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::BlockTime
+impl core::clone::Clone for bitcoin_units::FeeRate
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::Weight
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::BadPositionError
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockHeightInterval
+impl core::clone::Clone for bitcoin_units::block::BlockMtp
+impl core::clone::Clone for bitcoin_units::block::BlockMtpInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::LockTime
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::clone::Clone for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::clone::Clone for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse_int::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse_int::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse_int::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::result::MathOp
+impl core::clone::Clone for bitcoin_units::result::NumOpError
+impl core::clone::Clone for bitcoin_units::sequence::Sequence
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::BlockTime
+impl core::cmp::Eq for bitcoin_units::FeeRate
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::Weight
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Eq for bitcoin_units::block::BlockMtp
+impl core::cmp::Eq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Eq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::result::MathOp
+impl core::cmp::Eq for bitcoin_units::result::NumOpError
+impl core::cmp::Eq for bitcoin_units::sequence::Sequence
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::BlockTime
+impl core::cmp::Ord for bitcoin_units::FeeRate
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::Weight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::Ord for bitcoin_units::block::BlockMtp
+impl core::cmp::Ord for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::Ord for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::Ord for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::BlockTime
+impl core::cmp::PartialEq for bitcoin_units::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::Weight
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::result::MathOp
+impl core::cmp::PartialEq for bitcoin_units::result::NumOpError
+impl core::cmp::PartialEq for bitcoin_units::sequence::Sequence
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::BlockTime
+impl core::cmp::PartialOrd for bitcoin_units::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::Weight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeightInterval
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtp
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockMtpInterval
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::cmp::PartialOrd for bitcoin_units::sequence::Sequence
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse_int::ParseIntError
+impl core::convert::From<&bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<&bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::convert::From<bitcoin_units::BlockTime> for u32
+impl core::convert::From<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::convert::From<bitcoin_units::Weight> for u64
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::BadPositionError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockHeightInterval> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtp> for u32
+impl core::convert::From<bitcoin_units::block::BlockMtpInterval> for u32
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::block::BlockMtp
+impl core::convert::From<bitcoin_units::locktime::absolute::MedianTimePast> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::LockTime> for bitcoin_units::sequence::Sequence
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOf512Seconds> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<bitcoin_units::locktime::relative::NumberOfBlocks> for bitcoin_units::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse_int::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::sequence::Sequence> for u32
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse_int::UnprefixedHexError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::From<u32> for bitcoin_units::BlockTime
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtp
+impl core::convert::From<u32> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::Weight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeightInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtp
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockMtpInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::LockTime
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::convert::TryFrom<bitcoin_units::block::BlockMtp> for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::convert::TryFrom<bitcoin_units::sequence::Sequence> for bitcoin_units::locktime::relative::LockTime
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::block::BlockHeightInterval
+impl core::default::Default for bitcoin_units::block::BlockMtpInterval
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::default::Default for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::default::Default for bitcoin_units::sequence::Sequence
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::BlockTime
+impl core::fmt::Debug for bitcoin_units::FeeRate
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::Weight
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Debug for bitcoin_units::block::BlockMtp
+impl core::fmt::Debug for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Debug for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::result::MathOp
+impl core::fmt::Debug for bitcoin_units::result::NumOpError
+impl core::fmt::Debug for bitcoin_units::sequence::Sequence
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::Weight
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::BadPositionError
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockHeightInterval
+impl core::fmt::Display for bitcoin_units::block::BlockMtp
+impl core::fmt::Display for bitcoin_units::block::BlockMtpInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::LockTime
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::fmt::Display for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::fmt::Display for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse_int::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse_int::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse_int::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::result::MathOp
+impl core::fmt::Display for bitcoin_units::result::NumOpError
+impl core::fmt::Display for bitcoin_units::sequence::Sequence
+impl core::fmt::LowerHex for bitcoin_units::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_units::sequence::Sequence
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::BlockTime
+impl core::hash::Hash for bitcoin_units::FeeRate
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::Weight
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockHeightInterval
+impl core::hash::Hash for bitcoin_units::block::BlockMtp
+impl core::hash::Hash for bitcoin_units::block::BlockMtpInterval
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::hash::Hash for bitcoin_units::locktime::relative::LockTime
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::hash::Hash for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::hash::Hash for bitcoin_units::sequence::Sequence
+impl core::iter::traits::accum::Sum for bitcoin_units::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockHeightInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockMtpInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::iter::traits::accum::Sum for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::BlockTime
+impl core::marker::Copy for bitcoin_units::FeeRate
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::Weight
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Copy for bitcoin_units::block::BlockMtp
+impl core::marker::Copy for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Copy for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Copy for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Copy for bitcoin_units::result::MathOp
+impl core::marker::Copy for bitcoin_units::result::NumOpError
+impl core::marker::Copy for bitcoin_units::sequence::Sequence
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::BlockTime
+impl core::marker::Freeze for bitcoin_units::FeeRate
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::Weight
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Freeze for bitcoin_units::block::BlockMtp
+impl core::marker::Freeze for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Freeze for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::result::MathOp
+impl core::marker::Freeze for bitcoin_units::result::NumOpError
+impl core::marker::Freeze for bitcoin_units::sequence::Sequence
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::BlockTime
+impl core::marker::Send for bitcoin_units::FeeRate
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::Weight
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Send for bitcoin_units::block::BlockMtp
+impl core::marker::Send for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Send for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Send for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Send for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Send for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::result::MathOp
+impl core::marker::Send for bitcoin_units::result::NumOpError
+impl core::marker::Send for bitcoin_units::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::BlockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::BadPositionError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeightInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtp
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockMtpInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::result::MathOp
+impl core::marker::StructuralPartialEq for bitcoin_units::result::NumOpError
+impl core::marker::StructuralPartialEq for bitcoin_units::sequence::Sequence
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::BlockTime
+impl core::marker::Sync for bitcoin_units::FeeRate
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::Weight
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Sync for bitcoin_units::block::BlockMtp
+impl core::marker::Sync for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Sync for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Sync for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::result::MathOp
+impl core::marker::Sync for bitcoin_units::result::NumOpError
+impl core::marker::Sync for bitcoin_units::sequence::Sequence
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::BlockTime
+impl core::marker::Unpin for bitcoin_units::FeeRate
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::Weight
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::BadPositionError
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockHeightInterval
+impl core::marker::Unpin for bitcoin_units::block::BlockMtp
+impl core::marker::Unpin for bitcoin_units::block::BlockMtpInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::LockTime
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::marker::Unpin for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse_int::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse_int::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse_int::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::result::MathOp
+impl core::marker::Unpin for bitcoin_units::result::NumOpError
+impl core::marker::Unpin for bitcoin_units::sequence::Sequence
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::FeeRate
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::Weight
+impl core::ops::arith::Add for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Weight
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::AddAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::AddAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::AddAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::AddAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div for bitcoin_units::Amount
+impl core::ops::arith::Div for bitcoin_units::SignedAmount
+impl core::ops::arith::Div for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Div<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<&core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Div<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::Amount
+impl core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<i64>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Amount
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::FeeRate
+impl core::ops::arith::Div<core::num::nonzero::NonZero<u64>> for bitcoin_units::Weight
+impl core::ops::arith::Div<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Div<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::Weight
+impl core::ops::arith::Div<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<&bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<&bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<bitcoin_units::Amount> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Amount> for u64
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::FeeRate> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for &i64
+impl core::ops::arith::Mul<bitcoin_units::SignedAmount> for i64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for &u64
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::Weight> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::Weight> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for u64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::Weight
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for i64
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl core::ops::arith::Mul<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Weight
+impl core::ops::arith::Mul<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem for bitcoin_units::Weight
+impl core::ops::arith::Rem<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<&i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<&u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<&u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<i64> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for &bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Weight
+impl core::ops::arith::Rem<u64> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::Weight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeight> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtp> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::Weight> for &bitcoin_units::Weight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtp
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Weight
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::ops::arith::SubAssign<&bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::Weight> for bitcoin_units::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl core::ops::arith::SubAssign<&bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl core::ops::arith::SubAssign<bitcoin_units::Amount> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl core::ops::arith::SubAssign<bitcoin_units::SignedAmount> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::BlockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::BadPositionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeightInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockMtpInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::error::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::NumberOfBlocks
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::InvalidTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::error::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse_int::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::MathOp
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::sequence::Sequence
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::Weight
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeightInterval
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtp
+impl core::str::traits::FromStr for bitcoin_units::block::BlockMtpInterval
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::LockTime
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::MedianTimePast
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOf512Seconds
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::NumberOfBlocks
+impl<'a, T> core::ops::arith::Add<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a, T> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::FeeRate> for bitcoin_units::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Weight> for bitcoin_units::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockHeightInterval> for bitcoin_units::block::BlockHeightInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockMtpInterval> for bitcoin_units::block::BlockMtpInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<i64>> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Div<&'a core::num::nonzero::NonZero<u64>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Div<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Div<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Amount> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::FeeRate> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::SignedAmount> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::Weight> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &u64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>> for &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &i64
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Mul<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Weight>> for &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Mul<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Mul<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Rem<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Rem<&'a i64> for &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Rem<&'a u64> for &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::FeeRate> for &bitcoin_units::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Weight> for &bitcoin_units::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeight> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockHeightInterval> for &bitcoin_units::block::BlockHeightInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtp> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtp
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::block::BlockMtpInterval> for &bitcoin_units::block::BlockMtpInterval
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::Amount>> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>> for &bitcoin_units::SignedAmount
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> bitcoin_units::result::NumOpResult<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_units::result::NumOpResult<T>
+impl<T: core::marker::Copy> core::marker::Copy for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign + core::marker::Copy> core::ops::arith::AddAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::AddAssign> core::ops::arith::AddAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign + core::marker::Copy> core::ops::arith::SubAssign for bitcoin_units::result::NumOpResult<T>
+impl<T: core::ops::arith::SubAssign> core::ops::arith::SubAssign<T> for bitcoin_units::result::NumOpResult<T>
+impl<T> bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Freeze for bitcoin_units::result::NumOpResult<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_units::result::NumOpResult<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_units::result::NumOpResult<T>
+impl<T> core::marker::Sync for bitcoin_units::result::NumOpResult<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_units::result::NumOpResult<T> where T: core::marker::Unpin
+impl<T> core::ops::arith::Add for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>, Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Add<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Add<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<&bitcoin_units::result::NumOpResult<T>> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<T> for bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::ops::arith::Sub<bitcoin_units::result::NumOpResult<T>> for &bitcoin_units::result::NumOpResult<T> where T: core::marker::Copy + core::ops::arith::Sub<Output = bitcoin_units::result::NumOpResult<T>>
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_units::result::NumOpResult<T> where T: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_units::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::NumOpResult::Valid(T)
+pub bitcoin_units::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_units::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::MedianTimePast)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::LockTime::Blocks(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::LockTime::Time(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Blocks(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByError::Time(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Incompatible(bitcoin_units::locktime::relative::NumberOf512Seconds)
+pub bitcoin_units::relative::error::IsSatisfiedByHeightError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidHeightError)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Incompatible(bitcoin_units::locktime::relative::NumberOfBlocks)
+pub bitcoin_units::relative::error::IsSatisfiedByTimeError::Satisfaction(bitcoin_units::locktime::relative::error::InvalidTimeError)
+pub bitcoin_units::result::MathOp::Add
+pub bitcoin_units::result::MathOp::Div
+pub bitcoin_units::result::MathOp::Mul
+pub bitcoin_units::result::MathOp::Neg
+pub bitcoin_units::result::MathOp::Rem
+pub bitcoin_units::result::MathOp::Sub
+pub bitcoin_units::result::NumOpResult::Error(bitcoin_units::result::NumOpError)
+pub bitcoin_units::result::NumOpResult::Valid(T)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::FeeRate::BROADCAST_MIN: Self
+pub const bitcoin_units::FeeRate::DUST: Self
+pub const bitcoin_units::FeeRate::MAX: Self
+pub const bitcoin_units::FeeRate::MIN: Self
+pub const bitcoin_units::FeeRate::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
+pub const bitcoin_units::Weight::MAX: Self
+pub const bitcoin_units::Weight::MAX_BLOCK: Self
+pub const bitcoin_units::Weight::MIN: Self
+pub const bitcoin_units::Weight::MIN_TRANSACTION: Self
+pub const bitcoin_units::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::Weight::ZERO: Self
+pub const bitcoin_units::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockHeightInterval::MAX: Self
+pub const bitcoin_units::block::BlockHeightInterval::MIN: Self
+pub const bitcoin_units::block::BlockHeightInterval::ZERO: Self
+pub const bitcoin_units::block::BlockMtp::MAX: Self
+pub const bitcoin_units::block::BlockMtp::MIN: Self
+pub const bitcoin_units::block::BlockMtp::ZERO: Self
+pub const bitcoin_units::block::BlockMtpInterval::MAX: Self
+pub const bitcoin_units::block::BlockMtpInterval::MIN: Self
+pub const bitcoin_units::block::BlockMtpInterval::ZERO: Self
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::absolute::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MAX: Self
+pub const bitcoin_units::locktime::absolute::MedianTimePast::MIN: Self
+pub const bitcoin_units::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_units::locktime::relative::LockTime::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOf512Seconds::ZERO: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MAX: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::MIN: Self
+pub const bitcoin_units::locktime::relative::NumberOfBlocks::ZERO: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_units::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_units::sequence::Sequence::FINAL: Self
+pub const bitcoin_units::sequence::Sequence::MAX: Self
+pub const bitcoin_units::sequence::Sequence::SIZE: usize
+pub const bitcoin_units::sequence::Sequence::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_fee_rate_floor(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub const fn bitcoin_units::Amount::div_by_weight_ceil(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::div_by_weight_floor(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub const fn bitcoin_units::Amount::from_btc_u16(whole_bitcoin: u16) -> Self
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::Amount::from_sat_u32(satoshi: u32) -> Self
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::BlockTime::from_u32(t: u32) -> Self
+pub const fn bitcoin_units::BlockTime::to_u32(self) -> u32
+pub const fn bitcoin_units::FeeRate::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kvb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_kwu(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_per_vb(rate: bitcoin_units::Amount) -> bitcoin_units::result::NumOpResult<Self>
+pub const fn bitcoin_units::FeeRate::from_sat_per_kvb(sat_kvb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_kwu(sat_kwu: u32) -> Self
+pub const fn bitcoin_units::FeeRate::from_sat_per_vb(sat_vb: u32) -> Self
+pub const fn bitcoin_units::FeeRate::mul_by_weight(self, weight: bitcoin_units::Weight) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::FeeRate::to_fee(self, weight: bitcoin_units::Weight) -> bitcoin_units::Amount
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kvb_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_kwu_floor(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::SignedAmount::abs(self) -> Self
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::SignedAmount::from_btc_i16(whole_bitcoin: i16) -> Self
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> core::result::Result<Self, bitcoin_units::amount::error::OutOfRangeError>
+pub const fn bitcoin_units::SignedAmount::from_sat_i32(satoshi: i32) -> Self
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_vb_unwrap(vb: u64) -> Self
+pub const fn bitcoin_units::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::Weight::mul_by_fee_rate(self, fee_rate: bitcoin_units::FeeRate) -> bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub const fn bitcoin_units::Weight::to_kwu_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::Weight::to_wu(self) -> u64
+pub const fn bitcoin_units::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockHeightInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeightInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtp::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtp::to_u32(self) -> u32
+pub const fn bitcoin_units::block::BlockMtpInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_ceil(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_relative_mtp_interval_floor(self) -> core::result::Result<bitcoin_units::locktime::relative::NumberOf512Seconds, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::block::BlockMtpInterval::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Height::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::absolute::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::from_u32(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::MedianTimePast::to_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_height(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_block_time(self) -> bool
+pub const fn bitcoin_units::locktime::relative::LockTime::is_same_unit(self, other: Self) -> bool
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_512_second_intervals(self) -> u16
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOf512Seconds::to_seconds(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::relative::NumberOfBlocks::to_height(self) -> u16
+pub const fn bitcoin_units::sequence::Sequence::to_consensus_u32(self) -> u32
+pub enum bitcoin_units::NumOpResult<T>
+pub enum bitcoin_units::absolute::LockTime
+pub enum bitcoin_units::locktime::absolute::LockTime
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::locktime::relative::LockTime
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::IsSatisfiedByError
+pub enum bitcoin_units::relative::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::IsSatisfiedByTimeError
+pub enum bitcoin_units::relative::LockTime
+pub enum bitcoin_units::relative::error::IsSatisfiedByError
+pub enum bitcoin_units::relative::error::IsSatisfiedByHeightError
+pub enum bitcoin_units::relative::error::IsSatisfiedByTimeError
+pub enum bitcoin_units::result::NumOpResult<T>
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Amount::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn &bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::add(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<T>::sub(self, rhs: bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: u64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: i64) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn &u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::Amount::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Amount::signed_sub(self, rhs: Self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::BlockTime::clone(&self) -> bitcoin_units::BlockTime
+pub fn bitcoin_units::BlockTime::cmp(&self, other: &bitcoin_units::BlockTime) -> core::cmp::Ordering
+pub fn bitcoin_units::BlockTime::eq(&self, other: &bitcoin_units::BlockTime) -> bool
+pub fn bitcoin_units::BlockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::BlockTime::from(t: u32) -> Self
+pub fn bitcoin_units::BlockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::BlockTime::partial_cmp(&self, other: &bitcoin_units::BlockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::FeeRate::add(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::add_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::clone(&self) -> bitcoin_units::FeeRate
+pub fn bitcoin_units::FeeRate::cmp(&self, other: &bitcoin_units::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::FeeRate::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::FeeRate::eq(&self, other: &bitcoin_units::FeeRate) -> bool
+pub fn bitcoin_units::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fee_wu(self, weight: bitcoin_units::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::FeeRate::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::FeeRate::partial_cmp(&self, other: &bitcoin_units::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::FeeRate::sub(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::FeeRate)
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: core::num::nonzero::NonZeroI64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i16>>(whole_bitcoin: T) -> Self
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<Self, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<Self, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Weight::add(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::add_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::clone(&self) -> bitcoin_units::Weight
+pub fn bitcoin_units::Weight::cmp(&self, other: &bitcoin_units::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::Weight::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: core::num::nonzero::NonZeroU64) -> Self::Output
+pub fn bitcoin_units::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::eq(&self, other: &bitcoin_units::Weight) -> bool
+pub fn bitcoin_units::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::partial_cmp(&self, other: &bitcoin_units::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Weight::rem(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::rem(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Weight::rem_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Weight::sub(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: &bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sub_assign(&mut self, rhs: bitcoin_units::Weight)
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::BadPositionError::clone(&self) -> bitcoin_units::amount::error::BadPositionError
+pub fn bitcoin_units::amount::error::BadPositionError::eq(&self, other: &bitcoin_units::amount::error::BadPositionError) -> bool
+pub fn bitcoin_units::amount::error::BadPositionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::BadPositionError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::checked_add(self, other: bitcoin_units::block::BlockHeightInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeight::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockHeightInterval>
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockHeightInterval::clone(&self) -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeightInterval::default() -> bitcoin_units::block::BlockHeightInterval
+pub fn bitcoin_units::block::BlockHeightInterval::eq(&self, other: &bitcoin_units::block::BlockHeightInterval) -> bool
+pub fn bitcoin_units::block::BlockHeightInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeightInterval::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeightInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeightInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockHeightInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: &bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub(self, rhs: bitcoin_units::block::BlockHeightInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockHeightInterval)
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockHeightInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockHeightInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::checked_add(self, other: bitcoin_units::block::BlockMtpInterval) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtp::checked_sub(self, other: Self) -> core::option::Option<bitcoin_units::block::BlockMtpInterval>
+pub fn bitcoin_units::block::BlockMtp::clone(&self) -> bitcoin_units::block::BlockMtp
+pub fn bitcoin_units::block::BlockMtp::cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtp::eq(&self, other: &bitcoin_units::block::BlockMtp) -> bool
+pub fn bitcoin_units::block::BlockMtp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtp::from(h: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::block::BlockMtp::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtp::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtp::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtp::new(timestamps: [bitcoin_units::BlockTime; 11]) -> Self
+pub fn bitcoin_units::block::BlockMtp::partial_cmp(&self, other: &bitcoin_units::block::BlockMtp) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtp) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtp::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::checked_add(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::checked_sub(self, other: Self) -> core::option::Option<Self>
+pub fn bitcoin_units::block::BlockMtpInterval::clone(&self) -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockMtpInterval::default() -> bitcoin_units::block::BlockMtpInterval
+pub fn bitcoin_units::block::BlockMtpInterval::eq(&self, other: &bitcoin_units::block::BlockMtpInterval) -> bool
+pub fn bitcoin_units::block::BlockMtpInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockMtpInterval::from(h: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockMtpInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockMtpInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockMtpInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: &bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub(self, rhs: bitcoin_units::block::BlockMtpInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: &bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockMtpInterval)
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockMtpInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::block::BlockMtpInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeHeightError
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::is_satisfied_by(self, height: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::LockTime::clone(&self) -> bitcoin_units::locktime::absolute::LockTime
+pub fn bitcoin_units::locktime::absolute::LockTime::eq(&self, other: &bitcoin_units::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::MedianTimePast) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_mtp(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by(self, height: bitcoin_units::locktime::absolute::Height, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_height(self, height: bitcoin_units::locktime::absolute::Height) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleHeightError>
+pub fn bitcoin_units::locktime::absolute::LockTime::is_satisfied_by_time(self, mtp: bitcoin_units::locktime::absolute::MedianTimePast) -> core::result::Result<bool, bitcoin_units::locktime::absolute::error::IncompatibleTimeError>
+pub fn bitcoin_units::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::clone(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::eq(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::is_satisfied_by(self, time: Self) -> bool
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::new(timestamps: [bitcoin_units::BlockTime; 11]) -> core::result::Result<Self, bitcoin_units::locktime::absolute::error::ConversionError>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::MedianTimePast) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(h: bitcoin_units::block::BlockMtp) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::MedianTimePast::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::error::ConversionError
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::incompatible(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleHeightError::lock(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::IncompatibleTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::incompatible(&self) -> bitcoin_units::locktime::absolute::MedianTimePast
+pub fn bitcoin_units::locktime::absolute::error::IncompatibleTimeError::lock(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::error::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::error::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::error::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::LockTime::clone(&self) -> bitcoin_units::locktime::relative::LockTime
+pub fn bitcoin_units::locktime::relative::LockTime::eq(&self, other: &bitcoin_units::locktime::relative::LockTime) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::NumberOfBlocks) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::NumberOf512Seconds) -> Self
+pub fn bitcoin_units::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::from_sequence(n: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by(self, other: Self) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_implied_by_sequence(self, other: bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by(self, chain_tip_height: bitcoin_units::block::BlockHeight, chain_tip_mtp: bitcoin_units::block::BlockMtp, utxo_mined_at_height: bitcoin_units::block::BlockHeight, utxo_mined_at_mtp: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_height(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError>
+pub fn bitcoin_units::locktime::relative::LockTime::is_satisfied_by_time(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError>
+pub fn bitcoin_units::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_units::locktime::relative::LockTime::to_sequence(self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::locktime::relative::LockTime::try_from(seq: bitcoin_units::sequence::Sequence) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::DisabledLockTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::clone(&self) -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::default() -> bitcoin_units::locktime::relative::NumberOf512Seconds
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::eq(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockMtp, utxo_mined_at: bitcoin_units::block::BlockMtp) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidTimeError>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOf512Seconds) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOf512Seconds::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::clone(&self) -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::default() -> bitcoin_units::locktime::relative::NumberOfBlocks
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::eq(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> bool
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::is_satisfied_by(self, chain_tip: bitcoin_units::block::BlockHeight, utxo_mined_at: bitcoin_units::block::BlockHeight) -> core::result::Result<bool, bitcoin_units::locktime::relative::error::InvalidHeightError>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::partial_cmp(&self, other: &bitcoin_units::locktime::relative::NumberOfBlocks) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(h: bitcoin_units::block::BlockHeightInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::NumberOfBlocks::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::DisabledLockTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidHeightError
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::InvalidTimeError
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::InvalidTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::InvalidTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::clone(&self) -> bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::eq(&self, other: &bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError) -> bool
+pub fn bitcoin_units::locktime::relative::error::IsSatisfiedByTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::error::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::error::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::error::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::clone(&self) -> bitcoin_units::parse_int::ParseIntError
+pub fn bitcoin_units::parse_int::ParseIntError::eq(&self, other: &bitcoin_units::parse_int::ParseIntError) -> bool
+pub fn bitcoin_units::parse_int::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::PrefixedHexError::clone(&self) -> bitcoin_units::parse_int::PrefixedHexError
+pub fn bitcoin_units::parse_int::PrefixedHexError::eq(&self, other: &bitcoin_units::parse_int::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::clone(&self) -> bitcoin_units::parse_int::UnprefixedHexError
+pub fn bitcoin_units::parse_int::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse_int::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse_int::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(e: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn bitcoin_units::parse_int::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse_int::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::parse_int::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::parse_int::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::parse_int::int_from_str<T: bitcoin_units::parse_int::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse_int::ParseIntError>
+pub fn bitcoin_units::result::MathOp::clone(&self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::MathOp::eq(&self, other: &bitcoin_units::result::MathOp) -> bool
+pub fn bitcoin_units::result::MathOp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::MathOp::is_addition(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_multiplication(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_negation(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_overflow(self) -> bool
+pub fn bitcoin_units::result::MathOp::is_subtraction(self) -> bool
+pub fn bitcoin_units::result::NumOpError::clone(&self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpError::eq(&self, other: &bitcoin_units::result::NumOpError) -> bool
+pub fn bitcoin_units::result::NumOpError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpError::is_div_by_zero(self) -> bool
+pub fn bitcoin_units::result::NumOpError::is_overflow(self) -> bool
+pub fn bitcoin_units::result::NumOpError::operation(self) -> bitcoin_units::result::MathOp
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::add_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::and_then<F>(self, op: F) -> Self where F: core::ops::function::FnOnce(T) -> Self
+pub fn bitcoin_units::result::NumOpResult<T>::clone(&self) -> bitcoin_units::result::NumOpResult<T>
+pub fn bitcoin_units::result::NumOpResult<T>::eq(&self, other: &bitcoin_units::result::NumOpResult<T>) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::expect(self, msg: &str) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::result::NumOpResult<T>::into_result(self) -> core::result::Result<T, bitcoin_units::result::NumOpError>
+pub fn bitcoin_units::result::NumOpResult<T>::is_error(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::is_valid(&self) -> bool
+pub fn bitcoin_units::result::NumOpResult<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, op: F) -> bitcoin_units::result::NumOpResult<U>
+pub fn bitcoin_units::result::NumOpResult<T>::ok(self) -> core::option::Option<T>
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: &bitcoin_units::result::NumOpResult<T>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: Self) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub(self, rhs: T) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<T>::sub_assign(&mut self, rhs: T)
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap(self) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_err(self) -> bitcoin_units::result::NumOpError
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or(self, default: T) -> T
+pub fn bitcoin_units::result::NumOpResult<T>::unwrap_or_else<F>(self, f: F) -> T where F: core::ops::function::FnOnce() -> T
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::add_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: &bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::from(a: bitcoin_units::Amount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: &u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, modulus: u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::rem(self, rhs: &u64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sub_assign(&mut self, rhs: bitcoin_units::Amount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Weight>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: &bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::from(a: bitcoin_units::SignedAmount) -> Self
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: &i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, modulus: i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::rem(self, rhs: &i64) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::FeeRate) -> Self::Output
+pub fn bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>) -> Self::Output
+pub fn bitcoin_units::sequence::Sequence::clone(&self) -> bitcoin_units::sequence::Sequence
+pub fn bitcoin_units::sequence::Sequence::cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_units::sequence::Sequence::default() -> Self
+pub fn bitcoin_units::sequence::Sequence::enables_absolute_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::eq(&self, other: &bitcoin_units::sequence::Sequence) -> bool
+pub fn bitcoin_units::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::sequence::Sequence::from(lt: bitcoin_units::locktime::relative::LockTime) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_units::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::PrefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::error::TimeOverflowError>
+pub fn bitcoin_units::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse_int::UnprefixedHexError>
+pub fn bitcoin_units::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::sequence::Sequence::is_final(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_height_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_rbf(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_relative_lock_time(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::is_time_locked(self) -> bool
+pub fn bitcoin_units::sequence::Sequence::partial_cmp(&self, other: &bitcoin_units::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_units::locktime::relative::LockTime>
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse_int::ParseIntError) -> Self
+pub fn i64::mul(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn i64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>) -> Self::Output
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeightInterval) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtp) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockMtpInterval) -> Self
+pub fn u32::from(sequence: bitcoin_units::sequence::Sequence) -> Self
+pub fn u32::from(t: bitcoin_units::BlockTime) -> Self
+pub fn u64::from(value: bitcoin_units::Weight) -> Self
+pub fn u64::mul(self, rhs: &bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::Weight) -> Self::Output
+pub fn u64::mul(self, rhs: bitcoin_units::result::NumOpResult<bitcoin_units::Amount>) -> Self::Output
+pub mod bitcoin_units
+pub mod bitcoin_units::absolute
+pub mod bitcoin_units::absolute::error
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::absolute::error
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::locktime::relative::error
+pub mod bitcoin_units::parse_int
+pub mod bitcoin_units::relative
+pub mod bitcoin_units::relative::error
+pub mod bitcoin_units::result
+pub mod bitcoin_units::sequence
+pub mod bitcoin_units::time
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(_)
+pub struct bitcoin_units::BlockHeightInterval(_)
+pub struct bitcoin_units::BlockMtp(_)
+pub struct bitcoin_units::BlockMtpInterval(_)
+pub struct bitcoin_units::BlockTime(_)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::Sequence(pub u32)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::absolute::Height(_)
+pub struct bitcoin_units::absolute::IncompatibleHeightError
+pub struct bitcoin_units::absolute::IncompatibleTimeError
+pub struct bitcoin_units::absolute::MedianTimePast(_)
+pub struct bitcoin_units::absolute::ParseHeightError(_)
+pub struct bitcoin_units::absolute::ParseTimeError(_)
+pub struct bitcoin_units::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::error::BadPositionError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(_)
+pub struct bitcoin_units::block::BlockHeightInterval(_)
+pub struct bitcoin_units::block::BlockMtp(_)
+pub struct bitcoin_units::block::BlockMtpInterval(_)
+pub struct bitcoin_units::block::TooBigForRelativeHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::MedianTimePast(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleHeightError
+pub struct bitcoin_units::locktime::absolute::error::IncompatibleTimeError
+pub struct bitcoin_units::locktime::absolute::error::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::error::ParseTimeError(_)
+pub struct bitcoin_units::locktime::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::locktime::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::locktime::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::locktime::relative::error::InvalidHeightError
+pub struct bitcoin_units::locktime::relative::error::InvalidTimeError
+pub struct bitcoin_units::locktime::relative::error::TimeOverflowError
+pub struct bitcoin_units::parse_int::PrefixedHexError(_)
+pub struct bitcoin_units::parse_int::UnprefixedHexError(_)
+pub struct bitcoin_units::relative::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::InvalidHeightError
+pub struct bitcoin_units::relative::InvalidTimeError
+pub struct bitcoin_units::relative::NumberOf512Seconds(_)
+pub struct bitcoin_units::relative::NumberOfBlocks(_)
+pub struct bitcoin_units::relative::TimeOverflowError
+pub struct bitcoin_units::relative::error::DisabledLockTimeError(_)
+pub struct bitcoin_units::relative::error::InvalidHeightError
+pub struct bitcoin_units::relative::error::InvalidTimeError
+pub struct bitcoin_units::relative::error::TimeOverflowError
+pub struct bitcoin_units::sequence::Sequence(pub u32)
+pub struct bitcoin_units::time::BlockTime(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::parse_int::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse_int::sealed::Sealed
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type &bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type &bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type &bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type &bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type &bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type &bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type &bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type &i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type &u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Add>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Div>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type bitcoin_units::Amount::Output = <bitcoin_units::Amount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::Amount::Output = bitcoin_units::result::NumOpResult<u64>
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Add>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::FeeRate::Output = <bitcoin_units::FeeRate as core::ops::arith::Sub>::Output
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::FeeRate
+pub type bitcoin_units::FeeRate::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Add>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<core::num::nonzero::NonZero<i64>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Div>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type bitcoin_units::SignedAmount::Output = <bitcoin_units::SignedAmount as core::ops::arith::Sub>::Output
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::result::NumOpResult<i64>
+pub type bitcoin_units::Weight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Add>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<core::num::nonzero::NonZero<u64>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Div>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Rem>::Output
+pub type bitcoin_units::Weight::Output = <bitcoin_units::Weight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::Weight::Output = bitcoin_units::Weight
+pub type bitcoin_units::Weight::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::Weight::Output = u64
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Add<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub<bitcoin_units::block::BlockHeightInterval>>::Output
+pub type bitcoin_units::block::BlockHeight::Output = <bitcoin_units::block::BlockHeight as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockHeightInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = <bitcoin_units::block::BlockHeightInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockHeightInterval::Output = bitcoin_units::block::BlockHeightInterval
+pub type bitcoin_units::block::BlockMtp::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Add<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub<bitcoin_units::block::BlockMtpInterval>>::Output
+pub type bitcoin_units::block::BlockMtp::Output = <bitcoin_units::block::BlockMtp as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtp
+pub type bitcoin_units::block::BlockMtp::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::block::BlockMtpInterval::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Add>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = <bitcoin_units::block::BlockMtpInterval as core::ops::arith::Sub>::Output
+pub type bitcoin_units::block::BlockMtpInterval::Output = bitcoin_units::block::BlockMtpInterval
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::error::ParseHeightError
+pub type bitcoin_units::locktime::absolute::LockTime::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::LockTime::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Err = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ConversionError
+pub type bitcoin_units::locktime::absolute::MedianTimePast::Error = bitcoin_units::locktime::absolute::error::ParseTimeError
+pub type bitcoin_units::locktime::relative::LockTime::Error = bitcoin_units::locktime::relative::error::DisabledLockTimeError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOf512Seconds::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Err = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::block::TooBigForRelativeHeightError
+pub type bitcoin_units::locktime::relative::NumberOfBlocks::Error = bitcoin_units::parse_int::ParseIntError
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Add>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub<T>>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = <bitcoin_units::result::NumOpResult<T> as core::ops::arith::Sub>::Output
+pub type bitcoin_units::result::NumOpResult<T>::Output = bitcoin_units::result::NumOpResult<T>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Div<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Mul<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Amount> as core::ops::arith::Rem<u64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Amount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Weight>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Weight>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Div<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Mul<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount> as core::ops::arith::Rem<i64>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::FeeRate>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = <bitcoin_units::result::NumOpResult<bitcoin_units::Weight> as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::FeeRate>>>::Output
+pub type bitcoin_units::result::NumOpResult<bitcoin_units::Weight>::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::SignedAmount>>::Output
+pub type i64::Output = <i64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>>>::Output
+pub type i64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::SignedAmount>
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Amount>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::Weight>>::Output
+pub type u64::Output = <u64 as core::ops::arith::Mul<bitcoin_units::result::NumOpResult<bitcoin_units::Amount>>>::Output
+pub type u64::Output = bitcoin_units::Weight
+pub type u64::Output = bitcoin_units::result::NumOpResult<bitcoin_units::Amount>
diff --git a/base58/Cargo.toml b/base58/Cargo.toml
index 7a64cf5abb..a87ec89073 100644
--- a/base58/Cargo.toml
+++ b/base58/Cargo.toml
@@ -9,7 +9,7 @@ categories = ["cryptography::cryptocurrencies", "encoding"]
 keywords = ["bitcoin", "base58", "encode", "decode", "checksum"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
@@ -22,7 +22,7 @@ hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = fa
 internals = { package = "bitcoin-internals", path = "../internals" }
 
 [dev-dependencies]
-hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }
+hex_lit = "0.1.1"
 
 [package.metadata.docs.rs]
 all-features = true
@@ -30,3 +30,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)' ] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/base58/README.md b/base58/README.md
index 4b530e94ed..34b576db74 100644
--- a/base58/README.md
+++ b/base58/README.md
@@ -19,12 +19,3 @@ obviously named ones differ from this crate because:
 
 This crate uses [bitcoin_hashes](https://crates.io/crates/bitcoin_hashes) when hashing to calculate
 the checksum.
-
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
-
-## Licensing
-
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](../LICENSE).
-We use the [SPDX license list](https://spdx.org/licenses/) and [SPDX IDs](https://spdx.dev/ids/).
diff --git a/base58/contrib/extra_lints.sh b/base58/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/base58/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/base58/src/error.rs b/base58/src/error.rs
index 6b7b21f6c3..2ec8f5be50 100644
--- a/base58/src/error.rs
+++ b/base58/src/error.rs
@@ -118,7 +118,7 @@ impl fmt::Display for IncorrectChecksumError {
 #[cfg(feature = "std")]
 impl std::error::Error for IncorrectChecksumError {}
 
-/// The decode base58 data was too short (require at least 4 bytes for checksum).
+/// The decoded base58 data was too short (require at least 4 bytes for checksum).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) struct TooShortError {
     /// The length of the decoded data.
diff --git a/base58/src/lib.rs b/base58/src/lib.rs
index be1026fbd5..85debd8718 100644
--- a/base58/src/lib.rs
+++ b/base58/src/lib.rs
@@ -8,7 +8,6 @@
 #![cfg(feature = "alloc")]
 #![no_std]
 // Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(bench, feature(test))]
 // Coding conventions.
 #![warn(missing_docs)]
@@ -21,7 +20,7 @@
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
 #![allow(clippy::incompatible_msrv)] // Has FPs and we're testing it which is more reliable anyway.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 extern crate alloc;
 
@@ -194,7 +193,7 @@ trait Buffer: Sized {
 }
 
 impl Buffer for Vec<u8> {
-    fn push(&mut self, val: u8) { Vec::push(self, val) }
+    fn push(&mut self, val: u8) { Self::push(self, val) }
 
     fn slice(&self) -> &[u8] { self }
 
@@ -202,7 +201,7 @@ impl Buffer for Vec<u8> {
 }
 
 impl<const N: usize> Buffer for ArrayVec<u8, N> {
-    fn push(&mut self, val: u8) { ArrayVec::push(self, val) }
+    fn push(&mut self, val: u8) { Self::push(self, val) }
 
     fn slice(&self) -> &[u8] { self.as_slice() }
 
@@ -253,7 +252,7 @@ where
 mod tests {
     use alloc::vec;
 
-    use hex::FromHex as _;
+    use hex_lit::hex;
 
     use super::*;
 
@@ -282,7 +281,7 @@ mod tests {
         assert_eq!(&res, exp);
 
         // Addresses
-        let addr = Vec::from_hex("00f8917303bfa8ef24f292e8fa1419b20460ba064d").unwrap();
+        let addr = hex!("00f8917303bfa8ef24f292e8fa1419b20460ba064d");
         assert_eq!(&encode_check(&addr[..]), "1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH");
     }
 
@@ -300,8 +299,8 @@ mod tests {
 
         // Addresses
         assert_eq!(
-            decode_check("1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH").ok(),
-            Some(Vec::from_hex("00f8917303bfa8ef24f292e8fa1419b20460ba064d").unwrap())
+            decode_check("1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH").ok().unwrap().as_slice(),
+            hex!("00f8917303bfa8ef24f292e8fa1419b20460ba064d")
         );
         // Non Base58 char.
         assert_eq!(decode("¢").unwrap_err(), InvalidCharacterError::new(194));
diff --git a/benches/Cargo.toml b/benches/Cargo.toml
new file mode 100644
index 0000000000..4836e2b802
--- /dev/null
+++ b/benches/Cargo.toml
@@ -0,0 +1,99 @@
+[package]
+name = "bitcoin-benches"
+version = "0.1.0"
+license = "CC0-1.0"
+description = "Criterion benchmarks for rust-bitcoin"
+edition = "2021"
+
+[dependencies]
+bitcoin = { path = "../bitcoin", default-features = false, features = ["std"] }
+bitcoin_hashes = { path = "../hashes" }
+chacha20-poly1305 = { path = "../chacha20_poly1305" }
+
+criterion = "0.7"
+hex_lit = "0.1.1"
+
+[lints.clippy]
+use_self = "warn"
+
+[[bench]]
+name = "block"
+path = "bitcoin/block.rs"
+harness = false
+
+[[bench]]
+name = "transaction"
+path = "bitcoin/transaction.rs"
+harness = false
+
+[[bench]]
+name = "witness"
+path = "bitcoin/witness.rs"
+harness = false
+
+
+[[bench]]
+name = "chacha20poly1305"
+path = "chacha20_poly1305/chacha20poly1305.rs"
+harness = false
+
+[[bench]]
+name = "chacha20"
+path = "chacha20_poly1305/chacha20.rs"
+harness = false
+
+
+[[bench]]
+name = "cmp"
+path = "hashes/cmp.rs"
+harness = false
+
+[[bench]]
+name = "hash160"
+path = "hashes/hash160.rs"
+harness = false
+
+[[bench]]
+name = "hmac"
+path = "hashes/hmac.rs"
+harness = false
+
+[[bench]]
+name = "ripemd160"
+path = "hashes/ripemd160.rs"
+harness = false
+
+[[bench]]
+name = "sha1"
+path = "hashes/sha1.rs"
+harness = false
+
+[[bench]]
+name = "sha3_256"
+path = "hashes/sha3_256.rs"
+harness = false
+
+[[bench]]
+name = "sha256"
+path = "hashes/sha256.rs"
+harness = false
+
+[[bench]]
+name = "sha384"
+path = "hashes/sha384.rs"
+harness = false
+
+[[bench]]
+name = "sha512_256"
+path = "hashes/sha512_256.rs"
+harness = false
+
+[[bench]]
+name = "sha512"
+path = "hashes/sha512.rs"
+harness = false
+
+[[bench]]
+name = "siphash24"
+path = "hashes/siphash24.rs"
+harness = false
diff --git a/benches/README.md b/benches/README.md
new file mode 100644
index 0000000000..c4fa673be2
--- /dev/null
+++ b/benches/README.md
@@ -0,0 +1,77 @@
+# Rust Bitcoin Benchmarks
+
+Criterion based benchmarks for `rust-bitcoin`.
+
+## Minimum Supported Rust Version (MSRV)
+
+This crate’s MSRV is determined by its Criterion dependency. It currently requires **Rust 1.81**.
+This higher MSRV applies only to the benches crate and does not affect other crates in this repository.
+
+## Running the benchmarks
+
+Examples below are run from within the crates folder `benches/`, if running from the repo root pass in `--manifest-path benches/Cargo.toml`.
+
+Run all benchmarks in this crate:
+
+```bash
+cargo bench
+```
+
+Run a specific benchmark target:
+
+```bash
+cargo bench --bench block
+```
+
+Pass options through to Criterion (see [More information](#more-information) for details):
+
+```bash
+# Save current results as a baseline named "before-change"
+cargo bench -- --save-baseline before-change
+
+# Compare to the saved baseline
+cargo bench -- --baseline before-change
+```
+
+View reports:
+
+- Criterion writes detailed html reports that are linked to in `target/criterion/report/index.html`.
+
+## Adding a new benchmark
+
+1. Create a new Rust file for your benchmark in the subfolder for the crate e.g. `benches/bitcoin/base58.rs`.
+2. Add it in `benches/Cargo.toml` including the path, with `harness = false`:
+
+```toml
+[[bench]]
+name = "base58"
+path = "bitcoin/base58.rs"
+harness = false
+```
+
+3. Criterion code template:
+
+```rust
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn bench_new_bench(c: &mut Criterion) {
+    c.bench_function("new_bench", |b| {
+        b.iter(|| {
+            // Benchmark code
+        })
+    });
+}
+
+criterion_group!(benches, bench_new_bench);
+criterion_main!(benches);
+```
+
+## More information
+
+- Criterion Book: <https://bheisler.github.io/criterion.rs/book/>
+- Criterion GitHub: <https://github.com/bheisler/criterion.rs>
+
+## Licensing
+
+The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](../LICENSE).
+We use the [SPDX license list](https://spdx.org/licenses/) and [SPDX IDs](https://spdx.dev/ids/).
diff --git a/benches/bitcoin/block.rs b/benches/bitcoin/block.rs
new file mode 100644
index 0000000000..6ac155c702
--- /dev/null
+++ b/benches/bitcoin/block.rs
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::time::Duration;
+use std::hint::black_box;
+
+use bitcoin::blockdata::block::Block;
+use bitcoin::consensus::{deserialize, Decodable, Encodable};
+use bitcoin::io::sink;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_block(c: &mut Criterion) {
+    let raw_block = include_bytes!("../../bitcoin/tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+    assert_eq!(raw_block.len(), 1_381_836);
+    let block: Block = deserialize(&raw_block[..]).unwrap();
+
+    let mut g = c.benchmark_group("block");
+    g.throughput(Throughput::Bytes(raw_block.len() as u64));
+    g.measurement_time(Duration::from_secs(10)).warm_up_time(Duration::from_secs(3));
+
+    g.bench_function(BenchmarkId::new("stream_reader", "big"), |b| {
+        let big_block = black_box(raw_block.as_ref());
+        b.iter(|| {
+            let mut reader = big_block;
+            let blk = Block::consensus_decode(&mut reader).unwrap();
+            black_box(blk);
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("serialize", "big"), |b| {
+        let mut data = Vec::with_capacity(raw_block.len());
+        b.iter(|| {
+            let result = block.consensus_encode(&mut data);
+            black_box(&result);
+            data.clear();
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("serialize_logic", "big"), |b| {
+        b.iter(|| {
+            let size = block.consensus_encode(&mut sink());
+            let _ = black_box(size);
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("deserialize", "big"), |b| {
+        b.iter(|| {
+            let blk: Block = deserialize(&raw_block[..]).unwrap();
+            black_box(blk);
+        });
+    });
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_block);
+criterion_main!(benches);
diff --git a/benches/bitcoin/transaction.rs b/benches/bitcoin/transaction.rs
new file mode 100644
index 0000000000..ab8101faa5
--- /dev/null
+++ b/benches/bitcoin/transaction.rs
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::blockdata::transaction::TransactionExt as _; // for total_size()
+use bitcoin::consensus::{encode, Encodable};
+use bitcoin::io::sink;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+
+fn bench_tx(c: &mut Criterion) {
+    let mut g = c.benchmark_group("transaction");
+
+    g.bench_function(BenchmarkId::new("size", "some"), |b| {
+        let mut tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
+        b.iter(|| {
+            black_box(black_box(&mut tx).total_size());
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("serialize", "some"), |b| {
+        let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
+        let mut data = Vec::with_capacity(SOME_TX.len() / 2);
+        b.iter(|| {
+            let result = tx.consensus_encode(&mut data);
+            black_box(&result);
+            data.clear();
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("serialize_logic", "some"), |b| {
+        let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
+        b.iter(|| {
+            let size = tx.consensus_encode(&mut sink());
+            let _ = black_box(size);
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("deserialize", "raw_bytes"), |b| {
+        let raw_tx = hex_lit::hex!(SOME_TX);
+        b.iter(|| {
+            let tx: Transaction = encode::deserialize(&raw_tx).unwrap();
+            black_box(tx);
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("deserialize_hex", "string"), |b| {
+        b.iter(|| {
+            let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
+            black_box(tx);
+        });
+    });
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_tx);
+criterion_main!(benches);
diff --git a/benches/bitcoin/witness.rs b/benches/bitcoin/witness.rs
new file mode 100644
index 0000000000..22adf16f6a
--- /dev/null
+++ b/benches/bitcoin/witness.rs
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin::blockdata::witness::Witness;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn bench_witness(c: &mut Criterion) {
+    let mut g = c.benchmark_group("witness");
+
+    g.bench_function(BenchmarkId::new("to_vec", "big"), |b| {
+        let raw_witness = [[1u8]; 5];
+        let witness = Witness::from_slice(&raw_witness);
+        b.iter(|| {
+            black_box(witness.to_vec());
+        });
+    });
+
+    g.bench_function(BenchmarkId::new("to_vec", "small"), |b| {
+        let raw_witness = vec![vec![1u8]; 3];
+        let witness = Witness::from_slice(&raw_witness);
+        b.iter(|| {
+            black_box(witness.to_vec());
+        });
+    });
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_witness);
+criterion_main!(benches);
diff --git a/benches/chacha20_poly1305/chacha20.rs b/benches/chacha20_poly1305/chacha20.rs
new file mode 100644
index 0000000000..9585929503
--- /dev/null
+++ b/benches/chacha20_poly1305/chacha20.rs
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::time::Duration;
+
+use chacha20_poly1305::{chacha20::ChaCha20, Key, Nonce};
+
+fn bench_chacha20(c: &mut Criterion) {
+    let mut g = c.benchmark_group("chacha20");
+    g.measurement_time(Duration::from_secs(5)).warm_up_time(Duration::from_secs(2));
+
+    for &size in &[10usize, 1024, 65536] {
+        let key = Key::new([0u8; 32]);
+        let nonce = Nonce::new([0u8; 12]);
+        let count = 1u32;
+        let mut cipher = ChaCha20::new(key, nonce, count);
+        let mut buf = vec![0u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("apply_keystream", size), |b| {
+            b.iter(|| {
+                cipher.apply_keystream(black_box(&mut buf));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_chacha20);
+criterion_main!(benches);
diff --git a/benches/chacha20_poly1305/chacha20poly1305.rs b/benches/chacha20_poly1305/chacha20poly1305.rs
new file mode 100644
index 0000000000..7719734b3a
--- /dev/null
+++ b/benches/chacha20_poly1305/chacha20poly1305.rs
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::time::Duration;
+
+use chacha20_poly1305::{ChaCha20Poly1305, Key, Nonce};
+
+fn bench_chacha20poly1305(c: &mut Criterion) {
+    let mut g = c.benchmark_group("chacha20poly1305");
+    g.measurement_time(Duration::from_secs(5)).warm_up_time(Duration::from_secs(2));
+
+    for &size in &[128usize, 1024, 16 * 1024, 64 * 1024] {
+        let key = Key::new([0u8; 32]);
+        let nonce = Nonce::new([0u8; 12]);
+
+        let pt = vec![0u8; size];
+        let aad: &[u8] = b"dummy_aad";
+
+        g.throughput(Throughput::Bytes(size as u64));
+
+        g.bench_function(BenchmarkId::new("encrypt_no_aad", size), |b| {
+            b.iter(|| {
+                let mut buf = pt.clone();
+                let cipher = ChaCha20Poly1305::new(key, nonce);
+                let tag = cipher.encrypt(black_box(&mut buf), None);
+                black_box(tag);
+            });
+        });
+
+        g.bench_function(BenchmarkId::new("encrypt_with_aad", size), |b| {
+            b.iter(|| {
+                let mut buf = pt.clone();
+                let cipher = ChaCha20Poly1305::new(key, nonce);
+                let tag = cipher.encrypt(black_box(&mut buf), Some(aad));
+                black_box(tag);
+            });
+        });
+
+        let mut ct = pt.clone();
+        let tag = ChaCha20Poly1305::new(key, nonce).encrypt(&mut ct, Some(aad));
+
+        g.bench_function(BenchmarkId::new("decrypt_ok", size), |b| {
+            b.iter(|| {
+                let mut buf = ct.clone();
+                let cipher = ChaCha20Poly1305::new(key, nonce);
+                let res = cipher.decrypt(black_box(&mut buf), tag, Some(aad));
+                res.unwrap();
+                black_box(());
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_chacha20poly1305);
+criterion_main!(benches);
diff --git a/benches/hashes/cmp.rs b/benches/hashes/cmp.rs
new file mode 100644
index 0000000000..13695c323f
--- /dev/null
+++ b/benches/hashes/cmp.rs
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha256, sha512};
+use bitcoin_hashes::cmp::fixed_time_eq;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn bench_cmp(c: &mut Criterion) {
+    let mut g = c.benchmark_group("cmp");
+
+    // 32-byte comparisons
+    let a32 = sha256::Hash::hash(&[0; 1]);
+    let b32eq = sha256::Hash::hash(&[0; 1]);
+    let b32ne = sha256::Hash::hash(&[1; 1]);
+
+    g.bench_function(BenchmarkId::new("ct_eq", 32), |b| {
+        b.iter(|| fixed_time_eq(black_box(a32.as_byte_array()), black_box(b32eq.as_byte_array())));
+    });
+    g.bench_function(BenchmarkId::new("slice_eq", 32), |b| {
+        b.iter(|| black_box(a32.as_byte_array() == b32eq.as_byte_array()));
+    });
+    g.bench_function(BenchmarkId::new("ct_ne", 32), |b| {
+        b.iter(|| fixed_time_eq(black_box(a32.as_byte_array()), black_box(b32ne.as_byte_array())));
+    });
+    g.bench_function(BenchmarkId::new("slice_ne", 32), |b| {
+        b.iter(|| black_box(a32.as_byte_array() == b32ne.as_byte_array()));
+    });
+
+    // 64-byte comparisons
+    let a64 = sha512::Hash::hash(&[0; 1]);
+    let b64eq = sha512::Hash::hash(&[0; 1]);
+    let b64ne = sha512::Hash::hash(&[1; 1]);
+
+    g.bench_function(BenchmarkId::new("ct_eq", 64), |b| {
+        b.iter(|| fixed_time_eq(black_box(a64.as_byte_array()), black_box(b64eq.as_byte_array())));
+    });
+    g.bench_function(BenchmarkId::new("slice_eq", 64), |b| {
+        b.iter(|| black_box(a64.as_byte_array() == b64eq.as_byte_array()));
+    });
+    g.bench_function(BenchmarkId::new("ct_ne", 64), |b| {
+        b.iter(|| fixed_time_eq(black_box(a64.as_byte_array()), black_box(b64ne.as_byte_array())));
+    });
+    g.bench_function(BenchmarkId::new("slice_ne", 64), |b| {
+        b.iter(|| black_box(a64.as_byte_array() == b64ne.as_byte_array()));
+    });
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_cmp);
+criterion_main!(benches);
diff --git a/benches/hashes/hash160.rs b/benches/hashes/hash160.rs
new file mode 100644
index 0000000000..452fd454d0
--- /dev/null
+++ b/benches/hashes/hash160.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{hash160, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_hash160(c: &mut Criterion) {
+    let mut g = c.benchmark_group("hash160");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = hash160::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_hash160);
+criterion_main!(benches);
diff --git a/benches/hashes/hmac.rs b/benches/hashes/hmac.rs
new file mode 100644
index 0000000000..adc90e515a
--- /dev/null
+++ b/benches/hashes/hmac.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha256, HashEngine as _, HmacEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_hmac(c: &mut Criterion) {
+    let mut g = c.benchmark_group("hmac_sha256");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_hmac);
+criterion_main!(benches);
diff --git a/benches/hashes/ripemd160.rs b/benches/hashes/ripemd160.rs
new file mode 100644
index 0000000000..b786e77af9
--- /dev/null
+++ b/benches/hashes/ripemd160.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{ripemd160, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_ripemd160(c: &mut Criterion) {
+    let mut g = c.benchmark_group("ripemd160");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = ripemd160::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_ripemd160);
+criterion_main!(benches);
diff --git a/benches/hashes/sha1.rs b/benches/hashes/sha1.rs
new file mode 100644
index 0000000000..a63773f594
--- /dev/null
+++ b/benches/hashes/sha1.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha1, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha1(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha1");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha1::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha1);
+criterion_main!(benches);
diff --git a/benches/hashes/sha256.rs b/benches/hashes/sha256.rs
new file mode 100644
index 0000000000..a8f2d1046a
--- /dev/null
+++ b/benches/hashes/sha256.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha256, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha256(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha256");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha256::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha256);
+criterion_main!(benches);
diff --git a/benches/hashes/sha384.rs b/benches/hashes/sha384.rs
new file mode 100644
index 0000000000..77004ccf27
--- /dev/null
+++ b/benches/hashes/sha384.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha384, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha384(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha384");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha384::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha384);
+criterion_main!(benches);
diff --git a/benches/hashes/sha3_256.rs b/benches/hashes/sha3_256.rs
new file mode 100644
index 0000000000..2d4e1087d2
--- /dev/null
+++ b/benches/hashes/sha3_256.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha3_256, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha3_256(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha3_256");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha3_256::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha3_256);
+criterion_main!(benches);
diff --git a/benches/hashes/sha512.rs b/benches/hashes/sha512.rs
new file mode 100644
index 0000000000..c72d9e61cb
--- /dev/null
+++ b/benches/hashes/sha512.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha512, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha512(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha512");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha512::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha512);
+criterion_main!(benches);
diff --git a/benches/hashes/sha512_256.rs b/benches/hashes/sha512_256.rs
new file mode 100644
index 0000000000..c4cc075d54
--- /dev/null
+++ b/benches/hashes/sha512_256.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{sha512_256, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_sha512_256(c: &mut Criterion) {
+    let mut g = c.benchmark_group("sha512_256");
+
+    for &size in &[10usize, 1024, 65536] {
+        let mut engine = sha512_256::Hash::engine();
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_sha512_256);
+criterion_main!(benches);
diff --git a/benches/hashes/siphash24.rs b/benches/hashes/siphash24.rs
new file mode 100644
index 0000000000..f25d6d664f
--- /dev/null
+++ b/benches/hashes/siphash24.rs
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use std::hint::black_box;
+
+use bitcoin_hashes::{siphash24, HashEngine};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+fn bench_siphash24(c: &mut Criterion) {
+    let mut g = c.benchmark_group("siphash24");
+
+    for &size in &[1024usize, 65536] {
+        let mut engine = siphash24::HashEngine::with_keys(0, 0);
+        let bytes = vec![1u8; size];
+        g.throughput(Throughput::Bytes(size as u64));
+        g.bench_function(BenchmarkId::new("engine_input", size), |b| {
+            b.iter(|| {
+                engine.input(black_box(&bytes));
+            });
+        });
+    }
+
+    // Hash-with-keys and to_u64 variants
+    let k0 = 0x_07_06_05_04_03_02_01_00;
+    let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
+    let bytes = vec![1u8; 1024];
+    g.throughput(Throughput::Bytes(bytes.len() as u64));
+    g.bench_function("hash_with_keys/1k", |b| {
+        b.iter(|| {
+            let _ = siphash24::Hash::hash_with_keys(k0, k1, black_box(&bytes));
+        });
+    });
+    g.bench_function("hash_to_u64_with_keys/1k", |b| {
+        b.iter(|| {
+            let _ = siphash24::Hash::hash_to_u64_with_keys(k0, k1, black_box(&bytes));
+        });
+    });
+
+    g.finish();
+}
+
+criterion_group!(benches, bench_siphash24);
+criterion_main!(benches);
diff --git a/bip158/CHANGELOG.md b/bip158/CHANGELOG.md
new file mode 100644
index 0000000000..bf34213b95
--- /dev/null
+++ b/bip158/CHANGELOG.md
@@ -0,0 +1,3 @@
+# 0.1.0 - 2025-12-09
+
+* Initial release of the `github.com/rust-bitcoin/rust-bitcoin/bip158` crate as `bip158`.
diff --git a/bip158/Cargo.toml b/bip158/Cargo.toml
new file mode 100644
index 0000000000..b0ac9c2cd3
--- /dev/null
+++ b/bip158/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "bitcoin-bip158"
+version = "0.0.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+license = "CC0-1.0"
+repository = "https://github.com/rust-bitcoin/rust-bitcoin"
+description = "Golomb-rice coded filters for set membership query."
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["bitcoin", "peer-to-peer", "cryptography"]
+readme = "README.md"
+edition = "2021"
+rust-version = "1.74.0"
+exclude = ["tests", "contrib"]
+
+[dependencies]
+
+[dev-dependencies]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/bip158/README.md b/bip158/README.md
new file mode 100644
index 0000000000..547ee29d28
--- /dev/null
+++ b/bip158/README.md
@@ -0,0 +1,3 @@
+# BIP-158
+
+Implementation of [BIP-158](https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki) golomb coded block filters for private light client set membership query.
diff --git a/bip158/contrib/extra_lints.sh b/bip158/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/bip158/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/bip158/contrib/test_vars.sh b/bip158/contrib/test_vars.sh
new file mode 100644
index 0000000000..88e2d26e18
--- /dev/null
+++ b/bip158/contrib/test_vars.sh
@@ -0,0 +1,14 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+#
+# disable verify unused vars, despite the fact that they are used when sourced
+# shellcheck disable=SC2034
+
+# Test all these features with "std" enabled.
+FEATURES_WITH_STD=""
+
+# Test all these features without "std" enabled.
+FEATURES_WITHOUT_STD=""
+
+# Run these examples.
+EXAMPLES=""
diff --git a/bip158/src/lib.rs b/bip158/src/lib.rs
new file mode 100644
index 0000000000..5ef8625780
--- /dev/null
+++ b/bip158/src/lib.rs
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Rust Bitcoin BIP-158 implementation.
+
+// Coding conventions.
+#![warn(missing_docs)]
+#![warn(deprecated_in_future)]
+#![doc(test(attr(warn(unused))))]
+// Pedantic lints that we enforce.
+#![warn(clippy::return_self_not_must_use)]
+// Exclude lints we don't think are valuable.
+#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+#![allow(clippy::manual_range_contains)] // More readable than clippy's format.
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
diff --git a/bitcoin/CHANGELOG.md b/bitcoin/CHANGELOG.md
index bbe596b713..64722ec9cf 100644
--- a/bitcoin/CHANGELOG.md
+++ b/bitcoin/CHANGELOG.md
@@ -1,39 +1,56 @@
-# Unreleased
+# 0.33.0-beta.0 - 2025-11-03
 
-- TODO: Make a comment about `Amount::MAX_MONEY` (perhaps here in `bitcoin` release notes as well as in `amount`)
+This series of beta releases is meant for two things:
 
-- Use MAX_MONEY in serde regression test [#3950](https://github.com/rust-bitcoin/rust-bitcoin/pull/3950)
+1. To allow testing of the upcoming `bitcoin v0.33.0`. Its been a long
+   time since we released and there is a lot in this.
 
-# 0.33.0-alpha.0 - 2024-11-18
+2. To allow testing of the `1.0.0` RC releases of:
 
-This series of alpha releases is meant for two things:
+   - `bitcoin-primitives`
+   - `bitcoin-units`
+   - `bitcoin-consensus-encoding`
 
-1. To facilitate testing of `primitives 0.101`.
-2. To allow testing of upcoming `1.0` releases of:
-
-   - `bitcoin_hashes`
-   - `hex`
-   - `bitcoin-io`
-   - `primitives`
-   - `units`
-   - `ordered`
-
-You likely want to explicitly set the version if doing testing. `cargo` can be surprising when there
-is a `-` in the version number.
+`cargo` can be surprising when there is a `-` in the version number
+(see discussion on [#5229](https://github.com/rust-bitcoin/rust-bitcoin/discussions/5229)).
 
 We do not currently intend on releasing `bitcoin 0.33.0` until the `1.0` releases above are done.
 
 For changes to our dependencies included in this release see:
 
-- `bitcoin_hashes 0.15`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/hashes/CHANGELOG.md)
+- `bitcoin_hashes 0.17`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/hashes/CHANGELOG.md)
+- `hex-conservative 1.0.0`: [changelog](https://github.com/rust-bitcoin/hex-conservative/blob/1.x/CHANGELOG.md)
 - `hex-conservative 0.3`: [changelog](https://github.com/rust-bitcoin/hex-conservative/blob/master/CHANGELOG.md)
 - `bitcoin-io 0.2`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/io/CHANGELOG.md)
-- `bitcoin-primitives: 0.101`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/primitives/CHANGELOG.md)
-- `bitcoin-units 0.2`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/units/CHANGELOG.md)
-- `bitcoinconsensus: 0.106.0+26`: [changelog](https://github.com/rust-bitcoin/rust-bitcoinconsensus/blob/master/CHANGELOG.md)
+- `bitcoin-primitives: 1.0.0-rc`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/primitives/CHANGELOG.md)
+- `bitcoin-units 1.0.0-rc`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/units/CHANGELOG.md)
+- `bitcoin-consensus-encoding 1.0.0-rc` [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/consensus_encoding/CHANGELOG.md)
+
+## Worthy on note
+
+This release introduces an upper limit on the `Amount` type.
+
+- Remove `Amount::MAX` and replace it with the value in `MAX_MONEY` [#3691](https://github.com/rust-bitcoin/rust-bitcoin/issues/3691)
+- Prepare to enforce `MAX_MONEY` invariant [#4164](https://github.com/rust-bitcoin/rust-bitcoin/pull/4164)
+- Enforce `MAX_MONEY` invariant in amount types [#4157](https://github.com/rust-bitcoin/rust-bitcoin/pull/4157)
+- Use `MAX_MONEY` in serde regression test [#3950](https://github.com/rust-bitcoin/rust-bitcoin/pull/3950)
+
+The `serde` serialization for `Psbt` has changed.
+
+- BREAKING: Change `Psbt` serde implementations [#4496](https://github.com/rust-bitcoin/rust-bitcoin/pull/4496)
 
 ## Changes
 
+- Deprecate unchecked `amount` ops [#3759](https://github.com/rust-bitcoin/rust-bitcoin/pull/3759)
+- Change parameter type used for whole bitcoin amounts [#3744](https://github.com/rust-bitcoin/rust-bitcoin/pull/3744)
+- Add `Weight::to_kwu_ceil` [#3740](https://github.com/rust-bitcoin/rust-bitcoin/pull/3740)
+- Remove `Weight::from_wu_usize` function [#3738](https://github.com/rust-bitcoin/rust-bitcoin/pull/3738)
+- Move script hash types to `primitives` [#3734](https://github.com/rust-bitcoin/rust-bitcoin/pull/3734)
+- units: Unify and flesh out ops impls [#3728](https://github.com/rust-bitcoin/rust-bitcoin/pull/3728)
+- units: Seal the `Integer` trait [#3724](https://github.com/rust-bitcoin/rust-bitcoin/pull/3724)
+- base58ck: Bump version to `0.2.0` [#3717](https://github.com/rust-bitcoin/rust-bitcoin/pull/3717)
+- Explicitly define `Ord` for `NodeInfo` [#3699](https://github.com/rust-bitcoin/rust-bitcoin/pull/3699)
+- Change `Amount::MAX` from `u64::MAX` to `Amount::MAX_MONEY` [#3693](https://github.com/rust-bitcoin/rust-bitcoin/pull/3693)
 - Fix psbt fuzz crash [#3667](https://github.com/rust-bitcoin/rust-bitcoin/pull/3667)
 - Update `from_next_work_required` to take an `i64` for timespan [#3660](https://github.com/rust-bitcoin/rust-bitcoin/pull/3660)
 - Account for data pushing opcodes in `is_standard_op_return` [#3643](https://github.com/rust-bitcoin/rust-bitcoin/pull/3643)
@@ -95,13 +112,13 @@ For changes to our dependencies included in this release see:
 - Pass keys by value [#2868](https://github.com/rust-bitcoin/rust-bitcoin/pull/2868)
 - Clarify the meaning of `Height` & `Time` based locktime [#2858](https://github.com/rust-bitcoin/rust-bitcoin/pull/2858)
 - Add API for extracting the inner payload of `RawNetworkMessage` [#2839](https://github.com/rust-bitcoin/rust-bitcoin/pull/2839)
-- Update `bitcoinconsensus` version to `0.106.0+26` [#2833] (https://github.com/rust-bitcoin/rust-bitcoin/pull/2833)
+- Update `bitcoinconsensus` version to `0.106.0+26` [#2833](https://github.com/rust-bitcoin/rust-bitcoin/pull/2833)
 - Make `difficulty_float` general to all networks [#2816](https://github.com/rust-bitcoin/rust-bitcoin/pull/2816)
 - Add const modifier to `Magic::from_bytes` [#2815](https://github.com/rust-bitcoin/rust-bitcoin/pull/2815)
 - Add an `AddressData` type [#2808](https://github.com/rust-bitcoin/rust-bitcoin/pull/2808)
 - Make `Address:p2sh_from_hash` public [#2795](https://github.com/rust-bitcoin/rust-bitcoin/pull/2795)
 - Enable getting the witness program from an address [#2796](https://github.com/rust-bitcoin/rust-bitcoin/pull/2796)
-- Enforce script size limit when hashing scripts [##2794](https://github.com/rust-bitcoin/rust-bitcoin/pull/2794https://github.com/rust-bitcoin/rust-bitcoin/pull/#2794)
+- Enforce script size limit when hashing scripts [#2794](https://github.com/rust-bitcoin/rust-bitcoin/pull/2794)
 - Deprecate `to_vec` in favour of `to_bytes` [#2768](https://github.com/rust-bitcoin/rust-bitcoin/pull/2768)
 - Flesh out hex unit parsing API [#2765](https://github.com/rust-bitcoin/rust-bitcoin/pull/2765)
 - Bench `base58` encoding and remove `SmallVec` to improve perf [#2759](https://github.com/rust-bitcoin/rust-bitcoin/pull/2759)
@@ -121,6 +138,21 @@ For changes to our dependencies included in this release see:
 - Change `TxIn::default()` to `TxIn::EMPTY_COINBASE` if appropriate.
 - Change `to_raw_hash()` to `to_byte_array()`.
 - `bitcoin::error::UnprefixedHexError` moved to `bitcoin::parse::UnprefixedHexError`.
+
+# 0.32.7 - 2025-07-30
+
+- Backport - Use `_u32` in `FeeRate` constructor instead of `_unchecked` [#4552](https://github.com/rust-bitcoin/rust-bitcoin/pull/4552)
+- Backport - Add support for pay to anchor outputs [#4691](https://github.com/rust-bitcoin/rust-bitcoin/pull/4691)
+- Backport - Remove `non_exhaustive` from `Network` [#4658](https://github.com/rust-bitcoin/rust-bitcoin/pull/4658)
+
+# 0.32.6 - 2025-05-06
+
+- Backport - Fix `is_invalid_use_of_sighash_single()` incompatibility with Bitcoin Core [#4122](https://github.com/rust-bitcoin/rust-bitcoin/pull/4122)
+- Backport - Backport witness fixes [#4101](https://github.com/rust-bitcoin/rust-bitcoin/pull/4101)
+- Backport - bip32: Return error when attempting to derive past maximum depth [#4434](https://github.com/rust-bitcoin/rust-bitcoin/pull/4434)
+- Backport - Add `XOnlyPublicKey` support for PSBT key retrieval and improve Taproot signing [#4443](https://github.com/rust-bitcoin/rust-bitcoin/pull/4443)
+- Backport - Add methods to retrieve inner types [#4450](https://github.com/rust-bitcoin/rust-bitcoin/pull/4450)
+
 # 0.32.5 - 2024-11-27
 
 - Backport - Re-export `bech32` crate [#3662](https://github.com/rust-bitcoin/rust-bitcoin/pull/3662)
@@ -138,7 +170,7 @@ For changes to our dependencies included in this release see:
 
 # 0.32.3 - 2024-09-27
 
-- Backport BIP-32 alias' without typo [#3252](https://github.com/rust-bitcoin/rust-bitcoin/pull/3252)
+- Backport BIP-0032 alias' without typo [#3252](https://github.com/rust-bitcoin/rust-bitcoin/pull/3252)
 
 # 0.32.2 - 2024-06-07
 
@@ -167,7 +199,7 @@ might be what you are after.
   - `sig` becomes `signature`
   - `hash_ty` becomes `sighash_type`
 - Rename `txid` to `compute_txid` [#2366](https://github.com/rust-bitcoin/rust-bitcoin/pull/2366)
-- In hardcoded BIP-32 derivation paths: Remove `m/` prefix requirement [#2451](https://github.com/rust-bitcoin/rust-bitcoin/pull/2451)
+- In hardcoded BIP-0032 derivation paths: Remove `m/` prefix requirement [#2451](https://github.com/rust-bitcoin/rust-bitcoin/pull/2451)
 
 ## Crate smashing
 
@@ -258,7 +290,7 @@ In particular consider having some type that implements `AsRef<Params>`, we have
 # 0.31.1 - 2024-01-09
 
 - Fix bug in `FeeRate::checked_mul_by_weight` [#2128](https://github.com/rust-bitcoin/rust-bitcoin/pull/2182)
-- Add BIP-32 types remove in 0.31 back in and mark as deprecated [#2258](https://github.com/rust-bitcoin/rust-bitcoin/pull/2258)
+- Add BIP-0032 types remove in 0.31 back in and mark as deprecated [#2258](https://github.com/rust-bitcoin/rust-bitcoin/pull/2258)
 
 # 0.31.0 - 2023-10-18
 
@@ -393,7 +425,7 @@ This release is big, to help users upgrade we wrote a blog post, please see http
     all types except `Vec` and arrays, replace where appropriate with `FromStr`.
 
 - Performance improvements:
-  - [Remove needless allocation from BIP-158 encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/1146)
+  - [Remove needless allocation from BIP-0158 encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/1146)
   - [Implement fast hex encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/1268) (usage added in a [later PR](https://github.com/rust-bitcoin/rust-bitcoin/pull/1476))
 
 - Testing improvements:
@@ -674,10 +706,10 @@ the case and how we broke both `rust-miniscript` and BDK.
 # 0.19.0 - 2019-08-16
 
 * Add `Amount` and `SignedAmount` types.
-* Add BIP-158 support with `BlockFilter` and related types.
+* Add BIP-0158 support with `BlockFilter` and related types.
 * Add `util::misc::signed_msg_hash()` for signing messages.
 * Add `MerkleBlock` and `PartialMerkleTree` types.
-* bip32: Support serde serializaton for types and add some utility methods:
+* bip32: Support serde serialization for types and add some utility methods:
     * `ChildNumber::increment`
     * `DerivationPath::children_from`
     * `DerivationPath::normal_children`
@@ -780,7 +812,7 @@ the case and how we broke both `rust-miniscript` and BDK.
 * Use modern `as_` `to_` `into_` conventions for array-wrapping types; impl `Display` rather than `ToString` for most types
 * Change `script::Instructions` iterator [to allow rejecting non-minimal pushes](https://github.com/rust-bitcoin/rust-bitcoin/pull/136);
   fix bug where errors would iterate forever.
-* Overhaul `util::Error`; introduce `serialize::Error` [and use it for `SimpleDecoder` and `SimpleDecoder` rather
+* Overhaul `util::Error`; introduce `serialize::Error` [and use it for `SimpleDecoder` and `SimpleEncoder` rather
   than parameterizing these over their error type](https://github.com/rust-bitcoin/rust-bitcoin/pull/137).
 * Overhaul `UDecimal` and `Decimal` serialization and parsing [and fix many lingering parsing bugs](https://github.com/rust-bitcoin/rust-bitcoin/pull/142)
 * [Update to serde 1.0 and strason 0.4](https://github.com/rust-bitcoin/rust-bitcoin/pull/125)
@@ -804,7 +836,7 @@ the case and how we broke both `rust-miniscript` and BDK.
 * The in-memory blockchain was moved into a dedicated project rust-bitcoin-chain.
 * Removed old script interpreter
 * A new optional feature "bitcoinconsensus" lets this library use Bitcoin Core's native
-script verifier, wrappend into Rust by the rust-bitcoinconsenus project.
+script verifier, wrapped into Rust by the rust-bitcoinconsensus project.
 See `Transaction::verify` and `Script::verify` methods.
 * Replaced Base58 traits with `encode_slice`, `check_encode_slice`, from and `from_check` functions in the base58 module.
 * Un-reversed the Debug output for Sha256dHash
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 075ddbd893..e94d6720cc 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin"
-version = "0.33.0-alpha.0"
+version = "0.33.0-beta.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
@@ -10,40 +10,41 @@ categories = ["cryptography::cryptocurrencies"]
 keywords = [ "crypto", "bitcoin" ]
 readme = "../README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 # If you change features or optional dependencies in any way please update the "# Cargo features" section in lib.rs as well.
 [features]
 default = [ "std", "secp-recovery" ]
-std = ["base58/std", "bech32/std", "hashes/std", "hex/std", "internals/std", "io/std", "primitives/std", "secp256k1/std", "units/std", "base64?/std", "bitcoinconsensus?/std"]
-rand-std = ["secp256k1/rand", "std"]
+std = ["base58/std", "bech32/std", "encoding/std", "hashes/std", "hex/std", "internals/std", "io/std", "primitives/std", "secp256k1/std", "units/std", "base64?/std", "bitcoinconsensus?/std"]
 rand = ["secp256k1/rand"]
-serde = ["dep:serde", "hashes/serde", "internals/serde", "primitives/serde", "secp256k1/serde", "units/serde"]
+serde = ["base64", "dep:serde", "hashes/serde", "internals/serde", "primitives/serde", "secp256k1/serde", "units/serde"]
+secp-global-context = ["secp256k1/global-context"]
 secp-lowmemory = ["secp256k1/lowmemory"]
 secp-recovery = ["secp256k1/recovery"]
 arbitrary = ["dep:arbitrary", "units/arbitrary", "primitives/arbitrary"]
 
 [dependencies]
-base58 = { package = "base58ck", path = "../base58", default-features = false, features = ["alloc"] }
+base58 = { package = "base58ck", path = "../base58", version = "0.2.0", default-features = false, features = ["alloc"] }
 bech32 = { version = "0.11.0", default-features = false, features = ["alloc"] }
-hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = false, features = ["alloc", "hex"] }
+hashes = { package = "bitcoin_hashes", path = "../hashes", version = "0.18.0", default-features = false, features = ["alloc", "hex"] }
+encoding = { package = "bitcoin-consensus-encoding", path = "../consensus_encoding", version = "=1.0.0-rc.2", default-features = false, features = ["alloc"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }
-internals = { package = "bitcoin-internals", path = "../internals", features = ["alloc", "hex"] }
-io = { package = "bitcoin-io", path = "../io", default-features = false, features = ["alloc", "hashes"] }
-primitives = { package = "bitcoin-primitives", path = "../primitives", default-features = false, features = ["alloc", "hex"] }
-secp256k1 = { version = "0.30.0", default-features = false, features = ["hashes", "alloc", "rand"] }
-units = { package = "bitcoin-units", path = "../units", default-features = false, features = ["alloc"] }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.2", features = ["alloc", "hex"] }
+io = { package = "bitcoin-io", path = "../io", version = "0.3.0", default-features = false, features = ["alloc", "hashes"] }
+primitives = { package = "bitcoin-primitives", path = "../primitives", version = "=1.0.0-rc.1", default-features = false, features = ["alloc", "hex"] }
+secp256k1 = { version = "0.32.0-beta.2", default-features = false, features = ["alloc"] }
+units = { package = "bitcoin-units", path = "../units", version = "=1.0.0-rc.3", default-features = false, features = ["alloc"] }
 
-arbitrary = { version = "1.4", optional = true }
+arbitrary = { version = "1.4.1", optional = true }
 base64 = { version = "0.22.0", optional = true, default-features = false, features = ["alloc"] }
 # `bitcoinconsensus` version includes metadata which indicates the version of Core. Use `cargo tree` to see it.
 bitcoinconsensus = { version = "0.106.0", default-features = false, optional = true }
-serde = { version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
+serde = { version = "1.0.195", default-features = false, features = [ "derive", "alloc" ], optional = true }
 
 [dev-dependencies]
 internals = { package = "bitcoin-internals", path = "../internals", features = ["test-serde"] }
-serde_json = "1.0.0"
+serde_json = "1.0.68"
 serde_test = "1.0.19"
 bincode = "1.3.1"
 hex_lit = "0.1.1"
@@ -55,37 +56,33 @@ rustdoc-args = ["--cfg", "docsrs"]
 [[example]]
 name = "bip32"
 
-[[example]]
-name = "handshake"
-required-features = ["rand-std"]
-
 [[example]]
 name = "ecdsa-psbt"
 required-features = ["std", "bitcoinconsensus"]
 
 [[example]]
 name = "ecdsa-psbt-simple"
-required-features = ["rand-std"]
+required-features = ["rand", "std"]
 
 [[example]]
 name = "create-p2wpkh-address"
-required-features = ["rand-std"]
+required-features = ["rand", "std"]
 
 [[example]]
 name = "sign-tx-segwit-v0"
-required-features = ["rand-std"]
+required-features = ["rand", "std"]
 
 [[example]]
 name = "sign-tx-taproot"
-required-features = ["rand-std"]
+required-features = ["rand", "std"]
 
 [[example]]
 name = "taproot-psbt"
-required-features = ["rand-std", "bitcoinconsensus"]
+required-features = ["rand", "std", "bitcoinconsensus"]
 
 [[example]]
 name = "taproot-psbt-simple"
-required-features = ["rand-std"]
+required-features = ["rand", "std"]
 
 [[example]]
 name = "sighash"
@@ -98,5 +95,13 @@ required-features = ["std"]
 name = "script"
 required-features = ["std"]
 
+[[example]]
+name = "serde"
+required-features = ["std", "serde"]
+
 [lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)'] }
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)', 'cfg(kani)'] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/bitcoin/contrib/extra_lints.sh b/bitcoin/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/bitcoin/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/bitcoin/contrib/test_vars.sh b/bitcoin/contrib/test_vars.sh
index f28ecdb33a..6b2d09e8dc 100644
--- a/bitcoin/contrib/test_vars.sh
+++ b/bitcoin/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test all these features with "std" enabled.
-FEATURES_WITH_STD="rand-std serde secp-recovery bitcoinconsensus base64 arbitrary"
+FEATURES_WITH_STD="rand serde secp-recovery bitcoinconsensus base64 arbitrary"
 
 # Test all these features without "std" or "alloc" enabled.
 FEATURES_WITHOUT_STD="rand serde secp-recovery bitcoinconsensus base64 arbitrary"
 
 # Run these examples.
-EXAMPLES="ecdsa-psbt:std,bitcoinconsensus sign-tx-segwit-v0:rand-std sign-tx-taproot:rand-std taproot-psbt:bitcoinconsensus,rand-std sighash:std"
+EXAMPLES="ecdsa-psbt:std,bitcoinconsensus sign-tx-segwit-v0:rand,std sign-tx-taproot:rand,std taproot-psbt:bitcoinconsensus,rand,std sighash:std serde:std,serde"
diff --git a/bitcoin/embedded/Cargo.toml b/bitcoin/embedded/Cargo.toml
index 8a6f7ecb96..fdf2c69f62 100644
--- a/bitcoin/embedded/Cargo.toml
+++ b/bitcoin/embedded/Cargo.toml
@@ -15,6 +15,9 @@ cortex-m-semihosting = "0.3.3"
 alloc-cortex-m = "0.4.1"
 bitcoin = { path="../", default-features = false, features = ["secp-lowmemory"] }
 
+[lints.clippy]
+use_self = "warn"
+
 [[bin]]
 name = "embedded"
 test = false
diff --git a/bitcoin/embedded/README.md b/bitcoin/embedded/README.md
index a249719039..e27f8dc76f 100644
--- a/bitcoin/embedded/README.md
+++ b/bitcoin/embedded/README.md
@@ -16,8 +16,7 @@ source ./scripts/env.sh && cargo +nightly run --target thumbv7m-none-eabi
 Output should be something like:
 
 ```text
-heap size 524288
-secp buf size 66240
+heap size 262144
 Seed WIF: L1HKVVLHXiUhecWnwFYF6L3shkf1E12HUmuZTESvBXUdx3yqVP1D
 Address: bc1qpx9t9pzzl4qsydmhyt6ctrxxjd4ep549np9993
 ```
diff --git a/bitcoin/embedded/src/main.rs b/bitcoin/embedded/src/main.rs
index c11ed734ed..97d971183f 100644
--- a/bitcoin/embedded/src/main.rs
+++ b/bitcoin/embedded/src/main.rs
@@ -7,15 +7,11 @@ extern crate alloc;
 extern crate bitcoin;
 
 use alloc::string::ToString;
-use alloc::vec;
 use core::panic::PanicInfo;
 
 use alloc_cortex_m::CortexMHeap;
 // use panic_halt as _;
 use bitcoin::{Address, Network, PrivateKey};
-use bitcoin::secp256k1::ffi::types::AlignedType;
-use bitcoin::secp256k1::Secp256k1;
-
 use cortex_m_rt::entry;
 use cortex_m_semihosting::{debug, hprintln};
 
@@ -31,23 +27,17 @@ fn main() -> ! {
 
     unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
 
-    let size = Secp256k1::preallocate_size();
-    hprintln!("secp buf size {}", size*16).unwrap();
-
     // Load a private key
     let raw = "L1HKVVLHXiUhecWnwFYF6L3shkf1E12HUmuZTESvBXUdx3yqVP1D";
     let pk = PrivateKey::from_wif(raw).unwrap();
     hprintln!("Seed WIF: {}", pk).unwrap();
 
-    let mut buf_ful = vec![AlignedType::zeroed(); size];
-    let secp = Secp256k1::preallocated_new(&mut buf_ful).unwrap();
-
     // Derive address
-    let pubkey = pk.public_key(&secp).try_into().unwrap();
+    let pubkey = pk.public_key().try_into().unwrap();
     let address = Address::p2wpkh(pubkey, Network::Bitcoin);
     hprintln!("Address: {}", address).unwrap();
 
-    assert_eq!(address.to_string(), "bc1qpx9t9pzzl4qsydmhyt6ctrxxjd4ep549np9993".to_string());
+    assert_eq!(address.to_string(), "bc1qpx9t9pzzl4qsydmhyt6ctrxxjd4ep549np9993");
     // exit QEMU
     // NOTE do not run this on hardware; it can corrupt OpenOCD state
     debug::exit(debug::EXIT_SUCCESS);
diff --git a/bitcoin/examples/bip32.rs b/bitcoin/examples/bip32.rs
index 41f3791ea6..886a03032b 100644
--- a/bitcoin/examples/bip32.rs
+++ b/bitcoin/examples/bip32.rs
@@ -3,8 +3,6 @@ use std::{env, process};
 use bitcoin::address::{Address, KnownHrp};
 use bitcoin::bip32::{ChildNumber, DerivationPath, Xpriv, Xpub};
 use bitcoin::hex::FromHex;
-use bitcoin::secp256k1::ffi::types::AlignedType;
-use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{CompressedPublicKey, NetworkKind};
 
 fn main() {
@@ -27,26 +25,21 @@ fn main() {
 
     let seed = Vec::from_hex(seed_hex).unwrap();
 
-    // we need secp256k1 context for key derivation
-    let mut buf: Vec<AlignedType> = Vec::new();
-    buf.resize(Secp256k1::preallocate_size(), AlignedType::zeroed());
-    let secp = Secp256k1::preallocated_new(buf.as_mut_slice()).unwrap();
-
     // calculate root key from seed
     let root = Xpriv::new_master(NetworkKind::Main, &seed);
     println!("Root key: {root}");
 
     // derive child xpub
     let path = "84h/0h/0h".parse::<DerivationPath>().unwrap();
-    let child = root.derive_xpriv(&secp, &path).expect("only deriving three steps");
+    let child = root.derive_xpriv(&path).expect("only deriving three steps");
     println!("Child at {path}: {child}");
-    let xpub = Xpub::from_xpriv(&secp, &child);
+    let xpub = Xpub::from_xpriv(&child);
     println!("Public key at {path}: {xpub}");
 
     // generate first receiving address at m/0/0
     // manually creating indexes this time
     let zero = ChildNumber::ZERO_NORMAL;
-    let public_key = xpub.derive_xpub(&secp, &[zero, zero]).unwrap().public_key;
+    let public_key = xpub.derive_xpub([zero, zero]).unwrap().public_key;
     let address = Address::p2wpkh(CompressedPublicKey(public_key), KnownHrp::Mainnet);
     println!("First receiving address: {address}");
 }
diff --git a/bitcoin/examples/create-p2wpkh-address.rs b/bitcoin/examples/create-p2wpkh-address.rs
index e92ffe5312..d1a327590d 100644
--- a/bitcoin/examples/create-p2wpkh-address.rs
+++ b/bitcoin/examples/create-p2wpkh-address.rs
@@ -1,14 +1,11 @@
-use bitcoin::secp256k1::{rand, Secp256k1};
+use bitcoin::secp256k1::rand;
 use bitcoin::{Address, CompressedPublicKey, Network, PrivateKey};
 
 /// Generate a P2WPKH (pay-to-witness-public-key-hash) address and print it
 /// along with the associated private key needed to transact.
 fn main() {
-    // Create new secp256k1 instance.
-    let secp = Secp256k1::new();
-
     // Generate secp256k1 public and private key pair.
-    let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
+    let (secret_key, public_key) = secp256k1::generate_keypair(&mut rand::rng());
 
     // Create a Bitcoin private key to be used on the Bitcoin mainnet.
     let private_key = PrivateKey::new(secret_key, Network::Bitcoin);
diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs
index 73f209bb2e..e57f8dcd4e 100644
--- a/bitcoin/examples/ecdsa-psbt-simple.rs
+++ b/bitcoin/examples/ecdsa-psbt-simple.rs
@@ -24,16 +24,15 @@
 //! The miner's fee will be 10,000 satoshis.
 use std::collections::BTreeMap;
 
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub};
+use bitcoin::ext::*;
 use bitcoin::key::WPubkeyHash;
 use bitcoin::locktime::absolute;
 use bitcoin::psbt::Input;
-use bitcoin::secp256k1::{Secp256k1, Signing};
-use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
-    consensus, transaction, Address, Amount, EcdsaSighashType, Network, OutPoint, Psbt, ScriptBuf,
-    Sequence, Transaction, TxIn, TxOut, Txid, Witness,
+    consensus, transaction, Address, Amount, EcdsaSighashType, Network, OutPoint, Psbt,
+    RedeemScriptBuf, ScriptPubKeyBuf, ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Txid,
+    Witness,
 };
 
 // The master xpriv, from which we derive the keys we control.
@@ -55,35 +54,27 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
 const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
-fn get_external_address_xpriv<C: Signing>(
-    secp: &Secp256k1<C>,
-    master_xpriv: Xpriv,
-    index: u32,
-) -> Xpriv {
+fn get_external_address_xpriv(master_xpriv: Xpriv, index: u32) -> Xpriv {
     let derivation_path =
         BIP84_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
     let child_xpriv =
-        master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+        master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
     let external_index = ChildNumber::ZERO_NORMAL;
     let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
 
-    child_xpriv.derive_xpriv(secp, &[external_index, idx]).expect("only deriving two more steps")
+    child_xpriv.derive_xpriv([external_index, idx]).expect("only deriving two more steps")
 }
 
 // Derive the internal address xpriv.
-fn get_internal_address_xpriv<C: Signing>(
-    secp: &Secp256k1<C>,
-    master_xpriv: Xpriv,
-    index: u32,
-) -> Xpriv {
+fn get_internal_address_xpriv(master_xpriv: Xpriv, index: u32) -> Xpriv {
     let derivation_path =
         BIP84_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
     let child_xpriv =
-        master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+        master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
     let internal_index = ChildNumber::ONE_NORMAL;
     let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
 
-    child_xpriv.derive_xpriv(secp, &[internal_index, idx]).expect("only deriving two more steps")
+    child_xpriv.derive_xpriv([internal_index, idx]).expect("only deriving two more steps")
 }
 
 // The address to send to.
@@ -109,7 +100,7 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
         vout: 0,
     };
 
-    let utxo_1 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 };
+    let utxo_1 = TxOut { amount: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 };
 
     let script_pubkey_2 = "bc1qy7swwpejlw7a2rp774pa8rymh8tw3xvd2x2xkd"
         .parse::<Address<_>>()
@@ -123,24 +114,22 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
         vout: 1,
     };
 
-    let utxo_2 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_2, script_pubkey: script_pubkey_2 };
+    let utxo_2 = TxOut { amount: DUMMY_UTXO_AMOUNT_INPUT_2, script_pubkey: script_pubkey_2 };
     vec![(out_point_1, utxo_1), (out_point_2, utxo_2)]
 }
 
 fn main() {
-    let secp = Secp256k1::new();
-
     // Get the individual xprivs we control. In a real application these would come from a stored secret.
     let master_xpriv = XPRIV.parse::<Xpriv>().expect("valid xpriv");
-    let xpriv_input_1 = get_external_address_xpriv(&secp, master_xpriv, 0);
-    let xpriv_input_2 = get_internal_address_xpriv(&secp, master_xpriv, 0);
-    let xpriv_change = get_internal_address_xpriv(&secp, master_xpriv, 1);
+    let xpriv_input_1 = get_external_address_xpriv(master_xpriv, 0);
+    let xpriv_input_2 = get_internal_address_xpriv(master_xpriv, 0);
+    let xpriv_change = get_internal_address_xpriv(master_xpriv, 1);
 
     // Get the PKs
-    let pk_input_1 = Xpub::from_xpriv(&secp, &xpriv_input_1).to_public_key();
-    let pk_input_2 = Xpub::from_xpriv(&secp, &xpriv_input_2).to_public_key();
+    let pk_input_1 = Xpub::from_xpriv(&xpriv_input_1).to_public_key();
+    let pk_input_2 = Xpub::from_xpriv(&xpriv_input_2).to_public_key();
     let pk_inputs = [pk_input_1, pk_input_2];
-    let pk_change = Xpub::from_xpriv(&secp, &xpriv_change).to_public_key();
+    let pk_change = Xpub::from_xpriv(&xpriv_change).to_public_key();
 
     // Get the Witness Public Key Hashes (WPKHs)
     let wpkhs: Vec<WPubkeyHash> = pk_inputs.iter().map(|pk| pk.wpubkey_hash()).collect();
@@ -158,27 +147,27 @@ fn main() {
         .into_iter()
         .map(|(outpoint, _)| TxIn {
             previous_output: outpoint,
-            script_sig: ScriptBuf::default(),
+            script_sig: ScriptSigBuf::default(),
             sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
             witness: Witness::default(),
         })
         .collect();
 
     // The spend output is locked to a key controlled by the receiver.
-    let spend = TxOut { value: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
+    let spend = TxOut { amount: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
 
     // The change output is locked to a key controlled by us.
     let change = TxOut {
-        value: CHANGE_AMOUNT,
-        script_pubkey: ScriptBuf::new_p2wpkh(pk_change.wpubkey_hash()), // Change comes back to us.
+        amount: CHANGE_AMOUNT,
+        script_pubkey: ScriptPubKeyBuf::new_p2wpkh(pk_change.wpubkey_hash()), // Change comes back to us.
     };
 
     // The transaction we want to sign and broadcast.
     let unsigned_tx = Transaction {
         version: transaction::Version::TWO,  // Post BIP 68.
         lock_time: absolute::LockTime::ZERO, // Ignore the locktime.
-        input: inputs,                       // Input is 0-indexed.
-        output: vec![spend, change],         // Outputs, order does not matter.
+        inputs,                              // Input is 0-indexed.
+        outputs: vec![spend, change],        // Outputs, order does not matter.
     };
 
     // Now we'll start the PSBT workflow.
@@ -203,14 +192,14 @@ fn main() {
     psbt.inputs = vec![
         Input {
             witness_utxo: Some(utxos[0].clone()),
-            redeem_script: Some(ScriptBuf::new_p2wpkh(wpkhs[0])),
+            redeem_script: Some(RedeemScriptBuf::new_p2wpkh(wpkhs[0])),
             bip32_derivation: bip32_derivations[0].clone(),
             sighash_type: Some(ty),
             ..Default::default()
         },
         Input {
             witness_utxo: Some(utxos[1].clone()),
-            redeem_script: Some(ScriptBuf::new_p2wpkh(wpkhs[1])),
+            redeem_script: Some(RedeemScriptBuf::new_p2wpkh(wpkhs[1])),
             bip32_derivation: bip32_derivations[1].clone(),
             sighash_type: Some(ty),
             ..Default::default()
@@ -218,7 +207,7 @@ fn main() {
     ];
 
     // Step 3: Signer role; that signs the PSBT.
-    psbt.sign(&master_xpriv, &secp).expect("valid signature");
+    psbt.sign(&master_xpriv).expect("valid signature");
 
     // Step 4: Finalizer role; that finalizes the PSBT.
     println!("PSBT Inputs: {:#?}", psbt.inputs);
diff --git a/bitcoin/examples/ecdsa-psbt.rs b/bitcoin/examples/ecdsa-psbt.rs
index 0ac297654c..70a4b3d4e0 100644
--- a/bitcoin/examples/ecdsa-psbt.rs
+++ b/bitcoin/examples/ecdsa-psbt.rs
@@ -31,17 +31,14 @@
 use std::collections::BTreeMap;
 use std::fmt;
 
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub};
 use bitcoin::consensus::encode;
-use bitcoin::consensus_validation::TransactionExt as _;
+use bitcoin::ext::*;
 use bitcoin::locktime::absolute;
 use bitcoin::psbt::{self, Input, Psbt, PsbtSighashType};
-use bitcoin::script::ScriptBufExt as _;
-use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
 use bitcoin::{
-    transaction, Address, Amount, CompressedPublicKey, Network, OutPoint, ScriptBuf, Sequence,
-    Transaction, TxIn, TxOut, Witness,
+    transaction, Address, Amount, CompressedPublicKey, Network, OutPoint, RedeemScriptBuf,
+    ScriptPubKeyBuf, ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Witness,
 };
 
 type Result<T> = std::result::Result<T, Error>;
@@ -53,7 +50,7 @@ const EXTENDED_MASTER_PRIVATE_KEY: &str = "tprv8ZgxMBicQKsPeSHZFZWT8zxie2dXWcwem
 const INPUT_UTXO_TXID: &str = "295f06639cde6039bf0c3dbf4827f0e3f2b2c2b476408e2f9af731a8d7a9c7fb";
 const INPUT_UTXO_VOUT: u32 = 0;
 const INPUT_UTXO_SCRIPT_PUBKEY: &str = "00149891eeb8891b3e80a2a1ade180f143add23bf5de";
-const INPUT_UTXO_VALUE: &str = "50 BTC";
+const INPUT_UTXO_AMOUNT: &str = "50 BTC";
 // Get this from the descriptor,
 // "wpkh([97f17dca/0'/0'/0']02749483607dafb30c66bd93ece4474be65745ce538c2d70e8e246f17e7a4e0c0c)#m9n56cx0".
 const INPUT_UTXO_DERIVATION_PATH: &str = "0h/0h/0h";
@@ -68,17 +65,15 @@ const CHANGE_AMOUNT_BTC: &str = "48.99999 BTC"; // 1000 sat transaction fee.
 const NETWORK: Network = Network::Regtest;
 
 fn main() -> Result<()> {
-    let secp = Secp256k1::new();
-
     let (offline, fingerprint, account_0_xpub, input_xpub) =
-        ColdStorage::new(&secp, EXTENDED_MASTER_PRIVATE_KEY)?;
+        ColdStorage::new(EXTENDED_MASTER_PRIVATE_KEY)?;
 
     let online = WatchOnly::new(account_0_xpub, input_xpub, fingerprint);
 
-    let created = online.create_psbt(&secp)?;
+    let created = online.create_psbt()?;
     let updated = online.update_psbt(created)?;
 
-    let signed = offline.sign_psbt(&secp, updated)?;
+    let signed = offline.sign_psbt(updated)?;
 
     let finalized = online.finalize_psbt(signed)?;
 
@@ -92,7 +87,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-// We cache the pubkeys for convenience because it requires a scep context to convert the private key.
+// We cache the pubkeys for convenience because it requires a secp256k1 context to convert the private key.
 /// An example of an offline signer i.e., a cold-storage device.
 struct ColdStorage {
     /// The master extended private key.
@@ -111,22 +106,21 @@ impl ColdStorage {
     /// # Returns
     ///
     /// The newly created signer along with the data needed to configure a watch-only wallet.
-    fn new<C: Signing>(secp: &Secp256k1<C>, xpriv: &str) -> Result<ExportData> {
+    fn new(xpriv: &str) -> Result<ExportData> {
         let master_xpriv = xpriv.parse::<Xpriv>()?;
-        let master_xpub = Xpub::from_xpriv(secp, &master_xpriv);
+        let master_xpub = Xpub::from_xpriv(&master_xpriv);
 
         // Hardened children require secret data to derive.
 
         let path = "84h/0h/0h".into_derivation_path()?;
-        let account_0_xpriv =
-            master_xpriv.derive_xpriv(secp, &path).expect("derivation path is short");
-        let account_0_xpub = Xpub::from_xpriv(secp, &account_0_xpriv);
+        let account_0_xpriv = master_xpriv.derive_xpriv(&path).expect("derivation path is short");
+        let account_0_xpub = Xpub::from_xpriv(&account_0_xpriv);
 
         let path = INPUT_UTXO_DERIVATION_PATH.into_derivation_path()?;
-        let input_xpriv = master_xpriv.derive_xpriv(secp, &path).expect("derivation path is short");
-        let input_xpub = Xpub::from_xpriv(secp, &input_xpriv);
+        let input_xpriv = master_xpriv.derive_xpriv(&path).expect("derivation path is short");
+        let input_xpub = Xpub::from_xpriv(&input_xpriv);
 
-        let wallet = ColdStorage { master_xpriv, master_xpub };
+        let wallet = Self { master_xpriv, master_xpub };
         let fingerprint = wallet.master_fingerprint();
 
         Ok((wallet, fingerprint, account_0_xpub, input_xpub))
@@ -136,12 +130,8 @@ impl ColdStorage {
     fn master_fingerprint(&self) -> Fingerprint { self.master_xpub.fingerprint() }
 
     /// Signs `psbt` with this signer.
-    fn sign_psbt<C: Signing + Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-        mut psbt: Psbt,
-    ) -> Result<Psbt> {
-        match psbt.sign(&self.master_xpriv, secp) {
+    fn sign_psbt(&self, mut psbt: Psbt) -> Result<Psbt> {
+        match psbt.sign(&self.master_xpriv) {
             Ok(keys) => assert_eq!(keys.len(), 1),
             Err((_, e)) => {
                 let e = e.get(&0).expect("at least one error");
@@ -152,7 +142,7 @@ impl ColdStorage {
     }
 }
 
-/// An example of an watch-only online wallet.
+/// An example of a watch-only online wallet.
 struct WatchOnly {
     /// The xpub for account 0 derived from derivation path "m/84h/0h/0h".
     account_0_xpub: Xpub,
@@ -171,30 +161,30 @@ impl WatchOnly {
     /// The reason for importing the `input_xpub` is so one can use bitcoind to grab a valid input
     /// to verify the workflow presented in this file.
     fn new(account_0_xpub: Xpub, input_xpub: Xpub, master_fingerprint: Fingerprint) -> Self {
-        WatchOnly { account_0_xpub, input_xpub, master_fingerprint }
+        Self { account_0_xpub, input_xpub, master_fingerprint }
     }
 
-    /// Creates the PSBT, in BIP174 parlance this is the 'Creator'.
-    fn create_psbt<C: Verification>(&self, secp: &Secp256k1<C>) -> Result<Psbt> {
+    /// Creates the PSBT, in BIP-0174 parlance this is the 'Creator'.
+    fn create_psbt(&self) -> Result<Psbt> {
         let to_address =
             RECEIVE_ADDRESS.parse::<Address<_>>()?.require_network(Network::Regtest)?;
         let to_amount = OUTPUT_AMOUNT_BTC.parse::<Amount>()?;
 
-        let (_, change_address, _) = self.change_address(secp)?;
+        let (_, change_address, _) = self.change_address()?;
         let change_amount = CHANGE_AMOUNT_BTC.parse::<Amount>()?;
 
         let tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![TxIn {
+            inputs: vec![TxIn {
                 previous_output: OutPoint { txid: INPUT_UTXO_TXID.parse()?, vout: INPUT_UTXO_VOUT },
-                script_sig: ScriptBuf::new(),
+                script_sig: ScriptSigBuf::new(),
                 sequence: Sequence::MAX, // Disable LockTime and RBF.
                 witness: Witness::default(),
             }],
-            output: vec![
-                TxOut { value: to_amount, script_pubkey: to_address.script_pubkey() },
-                TxOut { value: change_amount, script_pubkey: change_address.script_pubkey() },
+            outputs: vec![
+                TxOut { amount: to_amount, script_pubkey: to_address.script_pubkey() },
+                TxOut { amount: change_amount, script_pubkey: change_address.script_pubkey() },
             ],
         };
 
@@ -203,14 +193,14 @@ impl WatchOnly {
         Ok(psbt)
     }
 
-    /// Updates the PSBT, in BIP174 parlance this is the 'Updater'.
+    /// Updates the PSBT, in BIP-0174 parlance this is the 'Updater'.
     fn update_psbt(&self, mut psbt: Psbt) -> Result<Psbt> {
         let mut input = Input { witness_utxo: Some(previous_output()), ..Default::default() };
 
         let pk = self.input_xpub.to_public_key();
         let wpkh = pk.wpubkey_hash();
 
-        let redeem_script = ScriptBuf::new_p2wpkh(wpkh);
+        let redeem_script = RedeemScriptBuf::new_p2wpkh(wpkh);
         input.redeem_script = Some(redeem_script);
 
         let fingerprint = self.master_fingerprint;
@@ -227,7 +217,7 @@ impl WatchOnly {
         Ok(psbt)
     }
 
-    /// Finalizes the PSBT, in BIP174 parlance this is the 'Finalizer'.
+    /// Finalizes the PSBT, in BIP-0174 parlance this is the 'Finalizer'.
     /// This is just an example. For a production-ready PSBT Finalizer, use [rust-miniscript](https://docs.rs/miniscript/latest/miniscript/psbt/trait.PsbtExt.html#tymethod.finalize)
     fn finalize_psbt(&self, mut psbt: Psbt) -> Result<Psbt> {
         if psbt.inputs.is_empty() {
@@ -251,16 +241,13 @@ impl WatchOnly {
         Ok(psbt)
     }
 
-    /// Returns data for the first change address (standard BIP84 derivation path
+    /// Returns data for the first change address (standard BIP-0084 derivation path
     /// "m/84h/0h/0h/1/0"). A real wallet would have access to the chain so could determine if an
     /// address has been used or not. We ignore this detail and just re-use the first change address
     /// without loss of generality.
-    fn change_address<C: Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-    ) -> Result<(CompressedPublicKey, Address, DerivationPath)> {
+    fn change_address(&self) -> Result<(CompressedPublicKey, Address, DerivationPath)> {
         let path = [ChildNumber::ONE_NORMAL, ChildNumber::ZERO_NORMAL];
-        let derived = self.account_0_xpub.derive_xpub(secp, &path)?;
+        let derived = self.account_0_xpub.derive_xpub(path)?;
 
         let pk = derived.to_public_key();
         let addr = Address::p2wpkh(pk, NETWORK);
@@ -276,17 +263,17 @@ fn input_derivation_path() -> Result<DerivationPath> {
 }
 
 fn previous_output() -> TxOut {
-    let script_pubkey = ScriptBuf::from_hex_no_length_prefix(INPUT_UTXO_SCRIPT_PUBKEY)
+    let script_pubkey = ScriptPubKeyBuf::from_hex_no_length_prefix(INPUT_UTXO_SCRIPT_PUBKEY)
         .expect("failed to parse input utxo scriptPubkey");
-    let amount = INPUT_UTXO_VALUE.parse::<Amount>().expect("failed to parse input utxo value");
+    let amount = INPUT_UTXO_AMOUNT.parse::<Amount>().expect("failed to parse input utxo amount");
 
-    TxOut { value: amount, script_pubkey }
+    TxOut { amount, script_pubkey }
 }
 
 struct Error(Box<dyn std::error::Error>);
 
 impl<T: std::error::Error + 'static> From<T> for Error {
-    fn from(e: T) -> Self { Error(Box::new(e)) }
+    fn from(e: T) -> Self { Self(Box::new(e)) }
 }
 
 impl fmt::Debug for Error {
diff --git a/bitcoin/examples/io.rs b/bitcoin/examples/io.rs
index 812c6b1664..1cabb4f41b 100644
--- a/bitcoin/examples/io.rs
+++ b/bitcoin/examples/io.rs
@@ -17,7 +17,7 @@ fn main() {
     // Encode to a custom type by implementing `bitcoin_io` traits.
     encode_to_custom_type();
 
-    // Encode to a foreign custom type by using the `bitcoin_io::bridge::FromStd` wrapper.
+    // Encode to a foreign custom type by using the `bitcoin_io::FromStd` wrapper.
     encode_using_wrapper();
 }
 
@@ -46,7 +46,7 @@ fn encode_decode_from_stdlib_type() {
 ///
 /// To use the `Encodable` (and `Decodable`) traits you can implement the `bitcoin_io` traits.
 fn encode_to_custom_type() {
-    /// A byte counter - counts how many bytes where written to it.
+    /// A byte counter - counts how many bytes were written to it.
     struct WriteCounter {
         count: usize,
     }
@@ -75,7 +75,7 @@ fn encode_to_custom_type() {
 /// Encodes to a custom type by using the `bitcoin_io::bridge` module.
 ///
 /// If you have a type that you don't control that implements `std::io::Write` you can still encode
-/// to it by way of the `io::bridge::FromStd` wrapper.
+/// to it by way of the `io::FromStd` wrapper.
 fn encode_using_wrapper() {
     use pretend_this_is_some_other_crate::WriteCounter;
 
@@ -96,7 +96,7 @@ fn encode_using_wrapper() {
 }
 
 mod pretend_this_is_some_other_crate {
-    /// A byte counter - counts how many bytes where written to it.
+    /// A byte counter - counts how many bytes were written to it.
     pub struct WriteCounter {
         count: usize,
     }
diff --git a/bitcoin/examples/script.rs b/bitcoin/examples/script.rs
index 930b4899e0..25585e0515 100644
--- a/bitcoin/examples/script.rs
+++ b/bitcoin/examples/script.rs
@@ -9,8 +9,8 @@
 
 use bitcoin::consensus::encode;
 use bitcoin::key::WPubkeyHash;
-use bitcoin::script::{self, ScriptBufExt, ScriptExt};
-use bitcoin::ScriptBuf;
+use bitcoin::script::{self, ScriptBufExt as _, ScriptExt as _};
+use bitcoin::WitnessScriptBuf;
 
 fn main() {
     let pk = "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb".parse::<WPubkeyHash>().unwrap();
@@ -18,63 +18,66 @@ fn main() {
     // TL;DR Use `to_hex_string_prefixed` and `from_hex_prefixed`.
     let script_code = script::p2wpkh_script_code(pk);
     let hex = script_code.to_hex_string_prefixed();
-    let decoded = ScriptBuf::from_hex_prefixed(&hex).unwrap();
+    let decoded = WitnessScriptBuf::from_hex_prefixed(&hex).unwrap();
     assert_eq!(decoded, script_code);
 
     // Or if you prefer: `to_hex_string_no_length_prefix` and `from_hex_no_length_prefix`.
     let script_code = script::p2wpkh_script_code(pk);
     let hex = script_code.to_hex_string_no_length_prefix();
-    let decoded = ScriptBuf::from_hex_no_length_prefix(&hex).unwrap();
+    let decoded = WitnessScriptBuf::from_hex_no_length_prefix(&hex).unwrap();
     assert_eq!(decoded, script_code);
 
     // Writes the script as human-readable eg, OP_DUP OP_HASH160 OP_PUSHBYTES_20 ...
     println!("human-readable script: {script_code}");
 
     // We do not implement parsing scripts from human-readable format.
-    // let decoded = s.parse::<ScriptBuf>().unwrap();
+    // let decoded = s.parse::<WitnessScriptBuf>().unwrap();
 
     // This is not equivalent to consensus encoding i.e., does not include the length prefix.
     let hex_lower_hex_trait = format!("{script_code:x}");
     println!("hex created using `LowerHex`: {hex_lower_hex_trait}");
 
     // The `deserialize_hex` function requires the length prefix.
-    assert!(encode::deserialize_hex::<ScriptBuf>(&hex_lower_hex_trait).is_err());
+    assert!(encode::deserialize_hex::<WitnessScriptBuf>(&hex_lower_hex_trait).is_err());
     // And so does `from_hex_prefixed`.
-    assert!(ScriptBuf::from_hex_prefixed(&hex_lower_hex_trait).is_err());
+    assert!(WitnessScriptBuf::from_hex_prefixed(&hex_lower_hex_trait).is_err());
     // But we provide an explicit constructor that does not.
-    assert_eq!(ScriptBuf::from_hex_no_length_prefix(&hex_lower_hex_trait).unwrap(), script_code);
+    assert_eq!(
+        WitnessScriptBuf::from_hex_no_length_prefix(&hex_lower_hex_trait).unwrap(),
+        script_code
+    );
 
     // This is consensus encoding i.e., includes the length prefix.
     let hex_inherent = script_code.to_hex_string_prefixed(); // Defined in `ScriptExt`.
     println!("hex created using inherent `to_hex_string_prefixed`: {hex_inherent}");
 
-    // The inverse of `to_hex_string_prefixed` is `from_hex_string_prefixed`.
-    let decoded = ScriptBuf::from_hex_prefixed(&hex_inherent).unwrap(); // Defined in `ScriptBufExt`.
+    // The inverse of `to_hex_string_prefixed` is `from_hex_prefixed`.
+    let decoded = WitnessScriptBuf::from_hex_prefixed(&hex_inherent).unwrap(); // Defined in `ScriptBufExt`.
     assert_eq!(decoded, script_code);
     // We can also parse the output of `to_hex_string_prefixed` using `deserialize_hex`.
-    let decoded = encode::deserialize_hex::<ScriptBuf>(&hex_inherent).unwrap();
+    let decoded = encode::deserialize_hex::<WitnessScriptBuf>(&hex_inherent).unwrap();
     assert_eq!(decoded, script_code);
 
     // We also support encode/decode using `consensus::encode` functions.
     let encoded = encode::serialize_hex(&script_code);
     println!("hex created using consensus::encode::serialize_hex: {encoded}");
 
-    let decoded: ScriptBuf = encode::deserialize_hex(&encoded).unwrap();
+    let decoded: WitnessScriptBuf = encode::deserialize_hex(&encoded).unwrap();
     assert_eq!(decoded, script_code);
 
-    // And we can mix these to calls because both include the length prefix.
+    // And we can mix these two calls because both include the length prefix.
     let encoded = encode::serialize_hex(&script_code);
-    let decoded = ScriptBuf::from_hex_prefixed(&encoded).unwrap();
+    let decoded = WitnessScriptBuf::from_hex_prefixed(&encoded).unwrap();
     assert_eq!(decoded, script_code);
 
     // Encode/decode using a byte vector.
     let encoded = encode::serialize(&script_code);
     assert_eq!(&encoded[1..], script_code.as_bytes()); // Shows that prefix is the first byte.
-    let decoded: ScriptBuf = encode::deserialize(&encoded).unwrap();
+    let decoded: WitnessScriptBuf = encode::deserialize(&encoded).unwrap();
     assert_eq!(decoded, script_code);
 
     // to/from bytes excludes the prefix, these are not encoding/decoding functions so this is sane.
-    let bytes = script_code.to_bytes();
-    let got = ScriptBuf::from_bytes(bytes);
+    let bytes = script_code.to_vec();
+    let got = WitnessScriptBuf::from_bytes(bytes);
     assert_eq!(got, script_code);
 }
diff --git a/bitcoin/examples/serde.rs b/bitcoin/examples/serde.rs
new file mode 100644
index 0000000000..a40f65f434
--- /dev/null
+++ b/bitcoin/examples/serde.rs
@@ -0,0 +1,59 @@
+//! Serializing with `serde` and `consensus::{Encodable, Decodable}`
+//!
+//! All types that implement consensus encoding traits can be serde de/serialized.
+//! For integer types that can have multiple units we typically provide a few different modules.
+
+use bitcoin::block::{Header, Version};
+use bitcoin::consensus::serde::Hex;
+use bitcoin::consensus::{self};
+use bitcoin::{
+    amount, fee_rate, Amount, BlockHash, BlockTime, CompactTarget, FeeRate, TxMerkleNode,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Foo {
+    /// Consensus encoded into hex is often the best option.
+    #[serde(with = "consensus::serde::With::<Hex>")]
+    header: Header,
+
+    /// This works but it's little-endian which may be hard to read.
+    ///
+    /// Integer wrapper types are more readable if they explicitly use a unit.
+    #[serde(with = "consensus::serde::With::<Hex>")]
+    this: Amount,
+
+    /// `Amount` can use sats or bitcoin (`as_btc`).
+    #[serde(with = "amount::serde::as_sat")]
+    that: Amount,
+
+    /// `FeeRate` can use kilo weight units or virtual bytes, both floor and ceil.
+    #[serde(with = "fee_rate::serde::as_sat_per_kwu_floor")]
+    fee_rate: FeeRate,
+}
+
+fn main() {
+    let f = Foo {
+        header: dummy_header(),
+        this: Amount::ONE_SAT,
+        that: Amount::ONE_BTC,
+        fee_rate: FeeRate::DUST,
+    };
+
+    let s = serde_json::to_string(&f).unwrap();
+    println!("{s}");
+
+    let deser = serde_json::from_str::<Foo>(&s).unwrap();
+    assert_eq!(deser, f);
+}
+
+fn dummy_header() -> Header {
+    Header {
+        version: Version::ONE,
+        prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
+        merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
+        time: BlockTime::from(2),
+        bits: CompactTarget::from_consensus(3),
+        nonce: 4,
+    }
+}
diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index bfa82216eb..1440cbbfe6 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -1,7 +1,7 @@
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
-use bitcoin::script::ScriptExt as _;
+use bitcoin::ext::*;
 use bitcoin::{
-    consensus, ecdsa, sighash, Amount, CompressedPublicKey, Script, ScriptBuf, Transaction,
+    consensus, ecdsa, sighash, Amount, CompressedPublicKey, ScriptPubKey, ScriptPubKeyBuf,
+    Transaction, WitnessScript,
 };
 use hex_lit::hex;
 
@@ -17,16 +17,16 @@ use hex_lit::hex;
 ///
 /// # Parameters
 ///
-/// * `raw_tx` - spending tx hex
-/// * `inp_idx` - spending tx input index
-/// * `amount` - ref tx output value in sats
+/// * `raw_tx` - the spending tx hex
+/// * `inp_idx` - the spending tx input index
+/// * `amount` - the ref tx output amount.
 fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
-    let inp = &tx.input[inp_idx];
+    let inp = &tx.inputs[inp_idx];
     let witness = &inp.witness;
     println!("Witness: {witness:?}");
 
-    // BIP-141: The witness must consist of exactly 2 items (≤ 520 bytes each). The first one a
+    // BIP-0141: The witness must consist of exactly 2 items (≤ 520 bytes each). The first one a
     // signature, and the second one a public key.
     assert_eq!(witness.len(), 2);
     let sig_bytes = witness.get(0).unwrap();
@@ -34,12 +34,12 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
 
     let sig = ecdsa::Signature::from_slice(sig_bytes).expect("failed to parse sig");
 
-    //BIP-143: "The item 5 : For P2WPKH witness program, the scriptCode is 0x1976a914{20-byte-pubkey-hash}88ac"
+    //BIP-0143: "The item 5 : For P2WPKH witness program, the scriptCode is 0x1976a914{20-byte-pubkey-hash}88ac"
     //this is nothing but a standard P2PKH script OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG:
     let pk = CompressedPublicKey::from_slice(pk_bytes).expect("failed to parse pubkey");
     let wpkh = pk.wpubkey_hash();
     println!("Script pubkey hash: {wpkh:x}");
-    let spk = ScriptBuf::new_p2wpkh(wpkh);
+    let spk = ScriptPubKeyBuf::new_p2wpkh(wpkh);
 
     let mut cache = sighash::SighashCache::new(&tx);
     let sighash = cache
@@ -48,20 +48,19 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
     println!("SegWit p2wpkh sighash: {sighash:x}");
     let msg = secp256k1::Message::from(sighash);
     println!("Message is {msg:x}");
-    let secp = secp256k1::Secp256k1::verification_only();
-    pk.verify(&secp, msg, sig).unwrap()
+    pk.verify(msg, sig).unwrap()
 }
 
 /// Computes sighash for a legacy multisig transaction input that spends either a p2sh or a p2ms output.
 ///
 /// # Parameters
 ///
-/// * `raw_tx` - spending tx hex
-/// * `inp_idx` - spending tx input index
-/// * `script_pubkey_bytes_opt` - Option with scriptPubKey bytes. If None, it's p2sh case, i.e., reftx output's scriptPubKey.type is "scripthash". In this case scriptPubkey is extracted from the spending transaction's scriptSig. If Some(), it's p2ms case, i.e., reftx output's scriptPubKey.type is "multisig", and the scriptPubkey is supplied from the referenced output.
+/// * `raw_tx` - the spending tx hex
+/// * `inp_idx` - the spending tx input index
+/// * `script_pubkey_bytes_opt` - the Option with scriptPubKey bytes. If None, it's p2sh case, i.e., reftx output's scriptPubKey.type is "scripthash". In this case scriptPubkey is extracted from the spending transaction's scriptSig. If Some(), it's p2ms case, i.e., reftx output's scriptPubKey.type is "multisig", and the scriptPubkey is supplied from the referenced output.
 fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt: Option<&[u8]>) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
-    let inp = &tx.input[inp_idx];
+    let inp = &tx.inputs[inp_idx];
     let script_sig = &inp.script_sig;
     println!("scriptSig is: {script_sig}");
     let cache = sighash::SighashCache::new(&tx);
@@ -79,14 +78,14 @@ fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt
             script_pubkey_p2sh.push_bytes().unwrap().as_bytes()
         }
     };
-    let script_code = Script::from_bytes(script_pubkey_bytes);
+    let script_code = ScriptPubKey::from_bytes(script_pubkey_bytes);
     let pushbytes_0 = instructions.remove(0).unwrap();
     assert!(
         pushbytes_0.push_bytes().unwrap().as_bytes().is_empty(),
         "first in ScriptSig must be PUSHBYTES_0 got {pushbytes_0:?}"
     );
 
-    //All other scriptSig instructions  must be signatures
+    //All other scriptSig instructions must be signatures
     for instr in instructions {
         let sig = ecdsa::Signature::from_slice(instr.unwrap().push_bytes().unwrap().as_bytes())
             .expect("failed to parse sig");
@@ -101,18 +100,18 @@ fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt
 ///
 /// # Parameters
 ///
-/// * `raw_tx` - spending tx hex
-/// * `inp_idx` - spending tx input index
-/// * `amount` - ref tx output value in sats
+/// * `raw_tx` - the spending tx hex
+/// * `inp_idx` - the spending tx input index
+/// * `amount` - the ref tx output amount.
 fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
-    let inp = &tx.input[inp_idx];
+    let inp = &tx.inputs[inp_idx];
     let witness = &inp.witness;
     println!("witness {witness:?}");
 
-    //last element is called witnessScript according to BIP141. It supersedes scriptPubKey.
+    //last element is called witnessScript according to BIP-0141. It supersedes scriptPubKey.
     let witness_script_bytes: &[u8] = witness.last().expect("out of bounds");
-    let witness_script = Script::from_bytes(witness_script_bytes);
+    let witness_script = WitnessScript::from_bytes(witness_script_bytes);
     let mut cache = sighash::SighashCache::new(&tx);
 
     //in an M of N multisig, the witness elements from 1 (0-based) to M-2 are signatures (with sighash flags as the last byte)
@@ -145,12 +144,12 @@ fn sighash_p2wpkh() {
 
     //vin:0
     let inp_idx = 0;
-    //output value from the referenced vout:0 from the referenced tx:
+    //output amount from the referenced vout:0 from the referenced tx:
     //bitcoin-cli getrawtransaction 752d675b9cc0bd14e0bd23969effee0005ad6d7e550dcc832f0216c7ffd4e15c  3
-    let ref_out_value = Amount::from_sat_u32(200000000);
+    let ref_out_amount = Amount::from_sat_u32(200000000);
 
     println!("\nsighash_p2wpkh:");
-    compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_value);
+    compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_amount);
 }
 
 fn sighash_p2sh_multisig_2x2() {
@@ -174,13 +173,13 @@ fn sighash_p2wsh_multisig_2x2() {
     //bitcoin-cli decodescript 52210289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2210323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea7352ae
     //its ASM is 2 0289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2 0323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea73 2 OP_CHECKMULTISIG
     let raw_tx = hex!("010000000001011b9eb4122976fad8f809ee4cea8ac8d1c5b6b8e0d0f9f93327a5d78c9a3945280000000000ffffffff02ba3e0d00000000002200201c3b09401aaa7c9709d118a75d301bdb2180fb68b2e9b3ade8ad4ff7281780cfa586010000000000220020a41d0d894799879ca1bd88c1c3f1c2fd4b1592821cc3c5bfd5be5238b904b09f040047304402201c7563e876d67b5702aea5726cd202bf92d0b1dc52c4acd03435d6073e630bac022032b64b70d7fba0cb8be30b882ea06c5f8ec7288d113459dd5d3e294214e2c96201483045022100f532f7e3b8fd01a0edc86de4870db4e04858964d0a609df81deb99d9581e6c2e02206d9e9b6ab661176be8194faded62f518cdc6ee74dba919e0f35d77cff81f38e5014752210289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2210323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea7352ae00000000");
-    //For the witness transaction sighash computation, we need its referenced output's value from the original transaction:
+    //For the witness transaction sighash computation, we need its referenced output's amount from the original transaction:
     //bitcoin-cli getrawtransaction 2845399a8cd7a52733f9f9d0e0b8b6c5d1c88aea4cee09f8d8fa762912b49e1b  3
-    //we need vout 0 value in sats:
-    let ref_out_value = Amount::from_sat_u32(968240);
+    //we need vout 0 amount:
+    let ref_out_amount = Amount::from_sat_u32(968240);
 
     println!("\nsighash_p2wsh_multisig_2x2:");
-    compute_sighash_p2wsh(&raw_tx, 0, ref_out_value);
+    compute_sighash_p2wsh(&raw_tx, 0, ref_out_amount);
 }
 
 fn sighash_p2ms_multisig_2x3() {
diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs
index e9a49385d5..5f64df68aa 100644
--- a/bitcoin/examples/sign-tx-segwit-v0.rs
+++ b/bitcoin/examples/sign-tx-segwit-v0.rs
@@ -2,15 +2,14 @@
 
 //! Demonstrate creating a transaction that spends to and from p2wpkh outputs.
 
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
+use bitcoin::ext::*;
 use bitcoin::key::WPubkeyHash;
 use bitcoin::locktime::absolute;
-use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing};
+use bitcoin::secp256k1::{rand, Message, SecretKey};
 use bitcoin::sighash::{EcdsaSighashType, SighashCache};
-use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
-    transaction, Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut,
-    Txid, Witness,
+    transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
+    Transaction, TxIn, TxOut, Txid, Witness,
 };
 
 const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_u32(20_000_000);
@@ -18,11 +17,9 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
 const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
 
 fn main() {
-    let secp = Secp256k1::new();
-
     // Get a secret key we control and the pubkeyhash of the associated pubkey.
     // In a real application these would come from a stored secret.
-    let (sk, wpkh) = senders_keys(&secp);
+    let (sk, wpkh) = senders_keys();
 
     // Get an address to send to.
     let address = receivers_address();
@@ -34,26 +31,26 @@ fn main() {
     // The input for the transaction we are constructing.
     let input = TxIn {
         previous_output: dummy_out_point, // The dummy output we are spending.
-        script_sig: ScriptBuf::default(), // For a p2wpkh script_sig is empty.
+        script_sig: ScriptSigBuf::default(), // For a p2wpkh script_sig is empty.
         sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
         witness: Witness::default(), // Filled in after signing.
     };
 
     // The spend output is locked to a key controlled by the receiver.
-    let spend = TxOut { value: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
+    let spend = TxOut { amount: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
 
     // The change output is locked to a key controlled by us.
     let change = TxOut {
-        value: CHANGE_AMOUNT,
-        script_pubkey: ScriptBuf::new_p2wpkh(wpkh), // Change comes back to us.
+        amount: CHANGE_AMOUNT,
+        script_pubkey: ScriptPubKeyBuf::new_p2wpkh(wpkh), // Change comes back to us.
     };
 
     // The transaction we want to sign and broadcast.
     let mut unsigned_tx = Transaction {
-        version: transaction::Version::TWO,  // Post BIP-68.
+        version: transaction::Version::TWO,  // Post BIP-0068.
         lock_time: absolute::LockTime::ZERO, // Ignore the locktime.
-        input: vec![input],                  // Input goes into index 0.
-        output: vec![spend, change],         // Outputs, order does not matter.
+        inputs: vec![input],                 // Input goes into index 0.
+        outputs: vec![spend, change],        // Outputs, order does not matter.
     };
     let input_index = 0;
 
@@ -71,11 +68,11 @@ fn main() {
 
     // Sign the sighash using the secp256k1 library (exported by rust-bitcoin).
     let msg = Message::from(sighash);
-    let signature = secp.sign_ecdsa(&msg, &sk);
+    let signature = secp256k1::ecdsa::sign(msg, &sk);
 
     // Update the witness stack.
     let signature = bitcoin::ecdsa::Signature { signature, sighash_type };
-    let pk = sk.public_key(&secp);
+    let pk = sk.public_key();
     *sighasher.witness_mut(input_index).unwrap() = Witness::p2wpkh(signature, pk);
 
     // Get the signed transaction.
@@ -88,9 +85,9 @@ fn main() {
 /// An example of keys controlled by the transaction sender.
 ///
 /// In a real application these would be actual secrets.
-fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> (SecretKey, WPubkeyHash) {
-    let sk = SecretKey::new(&mut rand::thread_rng());
-    let pk = bitcoin::PublicKey::new(sk.public_key(secp));
+fn senders_keys() -> (SecretKey, WPubkeyHash) {
+    let sk = SecretKey::new(&mut rand::rng());
+    let pk = bitcoin::PublicKey::new(sk.public_key());
     let wpkh = pk.wpubkey_hash().expect("key is compressed");
 
     (sk, wpkh)
@@ -113,19 +110,19 @@ fn receivers_address() -> Address {
 ///
 /// An utxo is described by the `OutPoint` (txid and index within the transaction that it was
 /// created). Using the out point one can get the transaction by `txid` and using the `vout` get the
-/// transaction value and script pubkey (`TxOut`) of the utxo.
+/// transaction amount and script pubkey (`TxOut`) of the utxo.
 ///
 /// This output is locked to keys that we control, in a real application this would be a valid
 /// output taken from a transaction that appears in the chain.
 fn dummy_unspent_transaction_output(wpkh: WPubkeyHash) -> (OutPoint, TxOut) {
-    let script_pubkey = ScriptBuf::new_p2wpkh(wpkh);
+    let script_pubkey = ScriptPubKeyBuf::new_p2wpkh(wpkh);
 
     let out_point = OutPoint {
         txid: Txid::from_byte_array([0xFF; 32]), // Arbitrary invalid dummy value.
         vout: 0,
     };
 
-    let utxo = TxOut { value: DUMMY_UTXO_AMOUNT, script_pubkey };
+    let utxo = TxOut { amount: DUMMY_UTXO_AMOUNT, script_pubkey };
 
     (out_point, utxo)
 }
diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index a68c968b4b..a1554966e6 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -2,15 +2,14 @@
 
 //! Demonstrate creating a transaction that spends to and from p2tr outputs.
 
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
+use bitcoin::ext::*;
 use bitcoin::key::{Keypair, TapTweak, TweakedKeypair, UntweakedPublicKey};
 use bitcoin::locktime::absolute;
-use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing, Verification};
+use bitcoin::secp256k1::{rand, SecretKey};
 use bitcoin::sighash::{Prevouts, SighashCache, TapSighashType};
-use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
-    transaction, Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut,
-    Txid, Witness,
+    transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf, ScriptSigBuf, Sequence,
+    Transaction, TxIn, TxOut, Txid, Witness,
 };
 
 const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_u32(20_000_000);
@@ -18,15 +17,13 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
 const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
 
 fn main() {
-    let secp = Secp256k1::new();
-
     // Get a keypair we control. In a real application these would come from a stored secret.
-    let keypair = senders_keys(&secp);
+    let keypair = senders_keys();
     let (internal_key, _parity) = keypair.x_only_public_key();
 
     // Get an unspent output that is locked to the key above that we control.
     // In a real application these would come from the chain.
-    let (dummy_out_point, dummy_utxo) = dummy_unspent_transaction_output(&secp, internal_key);
+    let (dummy_out_point, dummy_utxo) = dummy_unspent_transaction_output(internal_key);
 
     // Get an address to send to.
     let address = receivers_address();
@@ -34,26 +31,26 @@ fn main() {
     // The input for the transaction we are constructing.
     let input = TxIn {
         previous_output: dummy_out_point, // The dummy output we are spending.
-        script_sig: ScriptBuf::default(), // For a p2tr script_sig is empty.
+        script_sig: ScriptSigBuf::default(), // For a p2tr script_sig is empty.
         sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
         witness: Witness::default(), // Filled in after signing.
     };
 
     // The spend output is locked to a key controlled by the receiver.
-    let spend = TxOut { value: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
+    let spend = TxOut { amount: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
 
     // The change output is locked to a key controlled by us.
     let change = TxOut {
-        value: CHANGE_AMOUNT,
-        script_pubkey: ScriptBuf::new_p2tr(&secp, internal_key, None), // Change comes back to us.
+        amount: CHANGE_AMOUNT,
+        script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None), // Change comes back to us.
     };
 
     // The transaction we want to sign and broadcast.
     let mut unsigned_tx = Transaction {
-        version: transaction::Version::TWO,  // Post BIP-68.
+        version: transaction::Version::TWO,  // Post BIP-0068.
         lock_time: absolute::LockTime::ZERO, // Ignore the locktime.
-        input: vec![input],                  // Input goes into index 0.
-        output: vec![spend, change],         // Outputs, order does not matter.
+        inputs: vec![input],                 // Input goes into index 0.
+        outputs: vec![spend, change],        // Outputs, order does not matter.
     };
     let input_index = 0;
 
@@ -69,9 +66,8 @@ fn main() {
         .expect("failed to construct sighash");
 
     // Sign the sighash using the secp256k1 library (exported by rust-bitcoin).
-    let tweaked: TweakedKeypair = keypair.tap_tweak(&secp, None);
-    let msg = Message::from(sighash);
-    let signature = secp.sign_schnorr(msg.as_ref(), tweaked.as_keypair());
+    let tweaked: TweakedKeypair = keypair.tap_tweak(None);
+    let signature = secp256k1::schnorr::sign(&sighash.to_byte_array(), tweaked.as_keypair());
 
     // Update the witness stack.
     let signature = bitcoin::taproot::Signature { signature, sighash_type };
@@ -87,9 +83,9 @@ fn main() {
 /// An example of keys controlled by the transaction sender.
 ///
 /// In a real application these would be actual secrets.
-fn senders_keys<C: Signing>(secp: &Secp256k1<C>) -> Keypair {
-    let sk = SecretKey::new(&mut rand::thread_rng());
-    Keypair::from_secret_key(secp, &sk)
+fn senders_keys() -> Keypair {
+    let sk = SecretKey::new(&mut rand::rng());
+    Keypair::from_secret_key(&sk)
 }
 
 /// A dummy address for the receiver.
@@ -105,27 +101,26 @@ fn receivers_address() -> Address {
         .expect("valid address for mainnet")
 }
 
-/// Constructs a new p2wpkh output locked to the key associated with `wpkh`.
+/// Constructs a new p2tr output locked to the key associated with `internal_key`.
 ///
 /// An utxo is described by the `OutPoint` (txid and index within the transaction that it was
 /// created). Using the out point one can get the transaction by `txid` and using the `vout` get the
-/// transaction value and script pubkey (`TxOut`) of the utxo.
+/// transaction amount and script pubkey (`TxOut`) of the utxo.
 ///
 /// This output is locked to keys that we control, in a real application this would be a valid
 /// output taken from a transaction that appears in the chain.
-fn dummy_unspent_transaction_output<C: Verification, K: Into<UntweakedPublicKey>>(
-    secp: &Secp256k1<C>,
+fn dummy_unspent_transaction_output<K: Into<UntweakedPublicKey>>(
     internal_key: K,
 ) -> (OutPoint, TxOut) {
     let internal_key = internal_key.into();
-    let script_pubkey = ScriptBuf::new_p2tr(secp, internal_key, None);
+    let script_pubkey = ScriptPubKeyBuf::new_p2tr(internal_key, None);
 
     let out_point = OutPoint {
         txid: Txid::from_byte_array([0xFF; 32]), // Arbitrary invalid dummy value.
         vout: 0,
     };
 
-    let utxo = TxOut { value: DUMMY_UTXO_AMOUNT, script_pubkey };
+    let utxo = TxOut { amount: DUMMY_UTXO_AMOUNT, script_pubkey };
 
     (out_point, utxo)
 }
diff --git a/bitcoin/examples/taproot-psbt-simple.rs b/bitcoin/examples/taproot-psbt-simple.rs
index c35dbe4635..6bb28580c2 100644
--- a/bitcoin/examples/taproot-psbt-simple.rs
+++ b/bitcoin/examples/taproot-psbt-simple.rs
@@ -22,16 +22,15 @@
 //! The miner's fee will be 10,000 satoshis.
 use std::collections::BTreeMap;
 
-use bitcoin::address::script_pubkey::ScriptBufExt as _;
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub};
+use bitcoin::ext::*;
 use bitcoin::key::UntweakedPublicKey;
 use bitcoin::locktime::absolute;
 use bitcoin::psbt::Input;
-use bitcoin::secp256k1::{Secp256k1, Signing};
-use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
-    consensus, transaction, Address, Amount, Network, OutPoint, Psbt, ScriptBuf, Sequence,
-    TapLeafHash, TapSighashType, Transaction, TxIn, TxOut, Txid, Witness, XOnlyPublicKey,
+    consensus, transaction, Address, Amount, Network, OutPoint, Psbt, ScriptPubKeyBuf,
+    ScriptSigBuf, Sequence, TapLeafHash, TapSighashType, Transaction, TxIn, TxOut, Txid, Witness,
+    XOnlyPublicKey,
 };
 
 // The master xpriv, from which we derive the keys we control.
@@ -53,35 +52,27 @@ const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
 const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
-fn get_external_address_xpriv<C: Signing>(
-    secp: &Secp256k1<C>,
-    master_xpriv: Xpriv,
-    index: u32,
-) -> Xpriv {
+fn get_external_address_xpriv(master_xpriv: Xpriv, index: u32) -> Xpriv {
     let derivation_path =
         BIP86_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
     let child_xpriv =
-        master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+        master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
     let external_index = ChildNumber::ZERO_NORMAL;
     let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
 
-    child_xpriv.derive_xpriv(secp, &[external_index, idx]).expect("only deriving two more steps")
+    child_xpriv.derive_xpriv([external_index, idx]).expect("only deriving two more steps")
 }
 
 // Derive the internal address xpriv.
-fn get_internal_address_xpriv<C: Signing>(
-    secp: &Secp256k1<C>,
-    master_xpriv: Xpriv,
-    index: u32,
-) -> Xpriv {
+fn get_internal_address_xpriv(master_xpriv: Xpriv, index: u32) -> Xpriv {
     let derivation_path =
         BIP86_DERIVATION_PATH.into_derivation_path().expect("valid derivation path");
     let child_xpriv =
-        master_xpriv.derive_xpriv(secp, &derivation_path).expect("only deriving three steps");
+        master_xpriv.derive_xpriv(&derivation_path).expect("only deriving three steps");
     let internal_index = ChildNumber::ONE_NORMAL;
     let idx = ChildNumber::from_normal_idx(index).expect("valid index number");
 
-    child_xpriv.derive_xpriv(secp, &[internal_index, idx]).expect("only deriving two more steps")
+    child_xpriv.derive_xpriv([internal_index, idx]).expect("only deriving two more steps")
 }
 
 // Get the Taproot Key Origin.
@@ -119,7 +110,7 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
         vout: 0,
     };
 
-    let utxo_1 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 };
+    let utxo_1 = TxOut { amount: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 };
 
     let script_pubkey_2 = "bc1pfd0jmmdnp278vppcw68tkkmquxtq50xchy7f6wdmjtjm7fgsr8dszdcqce"
         .parse::<Address<_>>()
@@ -133,23 +124,21 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
         vout: 1,
     };
 
-    let utxo_2 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_2, script_pubkey: script_pubkey_2 };
+    let utxo_2 = TxOut { amount: DUMMY_UTXO_AMOUNT_INPUT_2, script_pubkey: script_pubkey_2 };
     vec![(out_point_1, utxo_1), (out_point_2, utxo_2)]
 }
 
 fn main() {
-    let secp = Secp256k1::new();
-
     // Get the individual xprivs we control. In a real application these would come from a stored secret.
     let master_xpriv = XPRIV.parse::<Xpriv>().expect("valid xpriv");
-    let xpriv_input_1 = get_external_address_xpriv(&secp, master_xpriv, 0);
-    let xpriv_input_2 = get_internal_address_xpriv(&secp, master_xpriv, 0);
-    let xpriv_change = get_internal_address_xpriv(&secp, master_xpriv, 1);
+    let xpriv_input_1 = get_external_address_xpriv(master_xpriv, 0);
+    let xpriv_input_2 = get_internal_address_xpriv(master_xpriv, 0);
+    let xpriv_change = get_internal_address_xpriv(master_xpriv, 1);
 
     // Get the PKs
-    let (pk_input_1, _) = Xpub::from_xpriv(&secp, &xpriv_input_1).public_key.x_only_public_key();
-    let (pk_input_2, _) = Xpub::from_xpriv(&secp, &xpriv_input_2).public_key.x_only_public_key();
-    let (pk_change, _) = Xpub::from_xpriv(&secp, &xpriv_change).public_key.x_only_public_key();
+    let (pk_input_1, _) = Xpub::from_xpriv(&xpriv_input_1).public_key.x_only_public_key();
+    let (pk_input_2, _) = Xpub::from_xpriv(&xpriv_input_2).public_key.x_only_public_key();
+    let (pk_change, _) = Xpub::from_xpriv(&xpriv_change).public_key.x_only_public_key();
 
     // Get the Tap Key Origins
     // Map of tap root X-only keys to origin info and leaf hashes contained in it.
@@ -178,27 +167,27 @@ fn main() {
         .into_iter()
         .map(|(outpoint, _)| TxIn {
             previous_output: outpoint,
-            script_sig: ScriptBuf::default(),
+            script_sig: ScriptSigBuf::default(),
             sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
             witness: Witness::default(),
         })
         .collect();
 
     // The spend output is locked to a key controlled by the receiver.
-    let spend = TxOut { value: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
+    let spend = TxOut { amount: SPEND_AMOUNT, script_pubkey: address.script_pubkey() };
 
     // The change output is locked to a key controlled by us.
     let change = TxOut {
-        value: CHANGE_AMOUNT,
-        script_pubkey: ScriptBuf::new_p2tr(&secp, pk_change, None), // Change comes back to us.
+        amount: CHANGE_AMOUNT,
+        script_pubkey: ScriptPubKeyBuf::new_p2tr(pk_change, None), // Change comes back to us.
     };
 
     // The transaction we want to sign and broadcast.
     let unsigned_tx = Transaction {
         version: transaction::Version::TWO,  // Post BIP 68.
         lock_time: absolute::LockTime::ZERO, // Ignore the locktime.
-        input: inputs,                       // Input is 0-indexed.
-        output: vec![spend, change],         // Outputs, order does not matter.
+        inputs,                              // Input is 0-indexed.
+        outputs: vec![spend, change],        // Outputs, order does not matter.
     };
 
     // Now we'll start the PSBT workflow.
@@ -227,7 +216,7 @@ fn main() {
     ];
 
     // Step 3: Signer role; that signs the PSBT.
-    psbt.sign(&master_xpriv, &secp).expect("valid signature");
+    psbt.sign(&master_xpriv).expect("valid signature");
 
     // Step 4: Finalizer role; that finalizes the PSBT.
     psbt.inputs.iter_mut().for_each(|input| {
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 39b70f9f4e..2b5ef494b5 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -77,27 +77,22 @@ const UTXO_3: P2trUtxo = P2trUtxo {
 
 use std::collections::BTreeMap;
 
-use bitcoin::address::script_pubkey::{BuilderExt as _, ScriptBufExt as _};
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpriv, Xpub};
 use bitcoin::consensus::encode;
-use bitcoin::consensus_validation::TransactionExt as _;
+use bitcoin::ext::*;
 use bitcoin::key::{TapTweak, XOnlyPublicKey};
 use bitcoin::opcodes::all::{OP_CHECKSIG, OP_CLTV, OP_DROP};
 use bitcoin::psbt::{self, Input, Output, Psbt, PsbtSighashType};
-use bitcoin::script::{ScriptBufExt as _, ScriptExt as _};
-use bitcoin::secp256k1::Secp256k1;
 use bitcoin::sighash::{self, SighashCache, TapSighash, TapSighashType};
 use bitcoin::taproot::{self, LeafVersion, TapLeafHash, TaprootBuilder, TaprootSpendInfo};
 use bitcoin::{
-    absolute, script, transaction, Address, Amount, Network, OutPoint, ScriptBuf, Transaction,
-    TxIn, TxOut, Witness,
+    absolute, script, transaction, Address, Amount, Network, OutPoint, ScriptPubKeyBuf,
+    ScriptSigBuf, TapScriptBuf, Transaction, TxIn, TxOut, Witness,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let secp = Secp256k1::new();
-
     println!("\n----------------");
-    println!("\nSTART EXAMPLE 1 - P2TR with a BIP86 commitment, signed with internal key\n");
+    println!("\nSTART EXAMPLE 1 - P2TR with a BIP-0086 commitment, signed with internal key\n");
 
     // Just some addresses for outputs from our wallets. Not really important.
     let to_address = "bcrt1p0p3rvwww0v9znrclp00uneq8ytre9kj922v8fxhnezm3mgsmn9usdxaefc"
@@ -114,14 +109,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .ok_or("fees more than input amount!")?;
 
     let tx_hex_string = encode::serialize_hex(&generate_bip86_key_spend_tx(
-        &secp,
         // The master extended private key from the descriptor in step 4
         BENEFACTOR_XPRIV_STR.parse::<Xpriv>()?,
         // Set these fields with valid data for the UTXO from step 5 above
         UTXO_1,
         vec![
-            TxOut { value: amount_to_send, script_pubkey: to_address.script_pubkey() },
-            TxOut { value: change_amount, script_pubkey: change_address.script_pubkey() },
+            TxOut { amount: amount_to_send, script_pubkey: to_address.script_pubkey() },
+            TxOut { amount: change_amount, script_pubkey: change_address.script_pubkey() },
         ],
     )?);
     println!(
@@ -220,7 +214,6 @@ struct P2trUtxo<'a> {
 
 #[allow(clippy::single_element_loop)]
 fn generate_bip86_key_spend_tx(
-    secp: &secp256k1::Secp256k1<secp256k1::All>,
     master_xpriv: Xpriv,
     input_utxo: P2trUtxo,
     outputs: Vec<TxOut>,
@@ -232,13 +225,13 @@ fn generate_bip86_key_spend_tx(
     let tx1 = Transaction {
         version: transaction::Version::TWO,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![TxIn {
+        inputs: vec![TxIn {
             previous_output: OutPoint { txid: input_utxo.txid.parse()?, vout: input_utxo.vout },
-            script_sig: ScriptBuf::new(),
+            script_sig: ScriptSigBuf::new(),
             sequence: bitcoin::Sequence(0xFFFFFFFF), // Ignore nSequence.
             witness: Witness::default(),
         }],
-        output: outputs,
+        outputs,
     };
     let mut psbt = Psbt::from_unsigned_tx(tx1)?;
 
@@ -256,9 +249,10 @@ fn generate_bip86_key_spend_tx(
 
     let mut input = Input {
         witness_utxo: {
-            let script_pubkey = ScriptBuf::from_hex_no_length_prefix(input_utxo.script_pubkey)
-                .expect("failed to parse input utxo scriptPubkey");
-            Some(TxOut { value: from_amount, script_pubkey })
+            let script_pubkey =
+                ScriptPubKeyBuf::from_hex_no_length_prefix(input_utxo.script_pubkey)
+                    .expect("failed to parse input utxo scriptPubkey");
+            Some(TxOut { amount: from_amount, script_pubkey })
         },
         tap_key_origins: origins,
         ..Default::default()
@@ -273,8 +267,8 @@ fn generate_bip86_key_spend_tx(
     let mut input_txouts = Vec::<TxOut>::new();
     for input in [&input_utxo].iter() {
         input_txouts.push(TxOut {
-            value: input.amount,
-            script_pubkey: ScriptBuf::from_hex_no_length_prefix(input.script_pubkey)?,
+            amount: input.amount,
+            script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(input.script_pubkey)?,
         });
     }
 
@@ -297,8 +291,7 @@ fn generate_bip86_key_spend_tx(
                 .get(&input.tap_internal_key.ok_or("internal key missing in PSBT")?)
                 .ok_or("missing Taproot key origin")?;
 
-            let secret_key =
-                master_xpriv.derive_xpriv(secp, &derivation_path)?.to_private_key().inner;
+            let secret_key = master_xpriv.derive_xpriv(derivation_path)?.to_private_key().inner;
             sign_psbt_taproot(
                 secret_key,
                 input.tap_internal_key.unwrap(),
@@ -306,7 +299,6 @@ fn generate_bip86_key_spend_tx(
                 input,
                 hash,
                 sighash_type,
-                secp,
             );
 
             Ok(())
@@ -331,8 +323,9 @@ fn generate_bip86_key_spend_tx(
     let tx = psbt.extract_tx_unchecked_fee_rate();
     tx.verify(|_| {
         Some(TxOut {
-            value: from_amount,
-            script_pubkey: ScriptBuf::from_hex_no_length_prefix(input_utxo.script_pubkey).unwrap(),
+            amount: from_amount,
+            script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(input_utxo.script_pubkey)
+                .unwrap(),
         })
     })
     .expect("failed to verify transaction");
@@ -347,7 +340,6 @@ struct BenefactorWallet {
     beneficiary_xpub: Xpub,
     current_spend_info: Option<TaprootSpendInfo>,
     next_psbt: Option<Psbt>,
-    secp: Secp256k1<secp256k1::All>,
     next: ChildNumber,
 }
 
@@ -361,7 +353,6 @@ impl BenefactorWallet {
             beneficiary_xpub,
             current_spend_info: None,
             next_psbt: None,
-            secp: Secp256k1::new(),
             next: ChildNumber::ZERO_NORMAL,
         })
     }
@@ -369,7 +360,7 @@ impl BenefactorWallet {
     fn time_lock_script(
         locktime: absolute::LockTime,
         beneficiary_key: XOnlyPublicKey,
-    ) -> ScriptBuf {
+    ) -> TapScriptBuf {
         script::Builder::new()
             .push_lock_time(locktime)
             .push_opcode(OP_CLTV)
@@ -386,7 +377,9 @@ impl BenefactorWallet {
     ) -> Result<(Transaction, Psbt), Box<dyn std::error::Error>> {
         if let ChildNumber::Normal { index } = self.next {
             if index > 0 && self.current_spend_info.is_some() {
-                return Err("transaction already exists, use refresh_inheritance_timelock to refresh the timelock".into());
+                return Err(
+                    "transaction already exists, use refresh_tx to refresh the timelock".into()
+                );
             }
         }
         // We use some other derivation path in this example for our inheritance protocol. The important thing is to ensure
@@ -394,11 +387,11 @@ impl BenefactorWallet {
         let derivation_path = format!("101/1/0/0/{}", self.next).parse::<DerivationPath>()?;
         let internal_keypair = self
             .master_xpriv
-            .derive_xpriv(&self.secp, &derivation_path)
+            .derive_xpriv(&derivation_path)
             .expect("derivation path is short")
-            .to_keypair(&self.secp);
+            .to_keypair();
         let beneficiary_key =
-            self.beneficiary_xpub.derive_xpub(&self.secp, &derivation_path)?.to_x_only_public_key();
+            self.beneficiary_xpub.derive_xpub(&derivation_path)?.to_x_only_public_key();
 
         // Build up the leaf script and combine with internal key into a Taproot commitment
         let script = Self::time_lock_script(lock_time, beneficiary_key);
@@ -406,36 +399,34 @@ impl BenefactorWallet {
 
         let taproot_spend_info = TaprootBuilder::new()
             .add_leaf(0, script.clone())?
-            .finalize(&self.secp, internal_keypair.x_only_public_key().0)
+            .finalize(internal_keypair.x_only_public_key().0)
             .expect("should be finalizable");
         self.current_spend_info = Some(taproot_spend_info.clone());
-        let script_pubkey = ScriptBuf::new_p2tr(
-            &self.secp,
+        let script_pubkey = ScriptPubKeyBuf::new_p2tr(
             taproot_spend_info.internal_key(),
             taproot_spend_info.merkle_root(),
         );
-        let value = (input_utxo.amount - ABSOLUTE_FEES)
+        let amount = (input_utxo.amount - ABSOLUTE_FEES)
             .expect("ABSOLUTE_FEES must be set below input amount");
 
-        // Spend a normal BIP86-like output as an input in our inheritance funding transaction
+        // Spend a normal BIP-0086-like output as an input in our inheritance funding transaction
         let tx = generate_bip86_key_spend_tx(
-            &self.secp,
             self.master_xpriv,
             input_utxo,
-            vec![TxOut { script_pubkey: script_pubkey.clone(), value }],
+            vec![TxOut { script_pubkey: script_pubkey.clone(), amount }],
         )?;
 
         // CREATOR + UPDATER
         let next_tx = Transaction {
             version: transaction::Version::TWO,
             lock_time,
-            input: vec![TxIn {
+            inputs: vec![TxIn {
                 previous_output: OutPoint { txid: tx.compute_txid(), vout: 0 },
-                script_sig: ScriptBuf::new(),
+                script_sig: ScriptSigBuf::new(),
                 sequence: bitcoin::Sequence(0xFFFFFFFD), // enable locktime and opt-in RBF
                 witness: Witness::default(),
             }],
-            output: vec![],
+            outputs: vec![],
         };
         let mut next_psbt = Psbt::from_unsigned_tx(next_tx)?;
         let mut origins = BTreeMap::new();
@@ -445,7 +436,7 @@ impl BenefactorWallet {
         );
         origins.insert(
             internal_keypair.x_only_public_key().0.into(),
-            (vec![], (self.master_xpriv.fingerprint(&self.secp), derivation_path)),
+            (vec![], (self.master_xpriv.fingerprint(), derivation_path)),
         );
         let ty = "SIGHASH_ALL".parse::<PsbtSighashType>()?;
         let mut tap_scripts = BTreeMap::new();
@@ -455,7 +446,7 @@ impl BenefactorWallet {
         );
 
         let input = Input {
-            witness_utxo: { Some(TxOut { value, script_pubkey }) },
+            witness_utxo: { Some(TxOut { amount, script_pubkey }) },
             tap_key_origins: origins,
             tap_merkle_root: taproot_spend_info.merkle_root(),
             sighash_type: Some(ty),
@@ -478,8 +469,8 @@ impl BenefactorWallet {
         if let Some(ref spend_info) = self.current_spend_info.clone() {
             let mut psbt = self.next_psbt.clone().expect("should have next_psbt");
             let input = &mut psbt.inputs[0];
-            let input_value = input.witness_utxo.as_ref().unwrap().value;
-            let output_value = (input_value - ABSOLUTE_FEES).into_result()?;
+            let input_amount = input.witness_utxo.as_ref().unwrap().amount;
+            let output_amount = (input_amount - ABSOLUTE_FEES).into_result()?;
 
             // We use some other derivation path in this example for our inheritance protocol. The important thing is to ensure
             // that we use an unhardened path so we can make use of xpubs.
@@ -487,13 +478,11 @@ impl BenefactorWallet {
                 format!("101/1/0/0/{}", self.next).parse::<DerivationPath>()?;
             let new_internal_keypair = self
                 .master_xpriv
-                .derive_xpriv(&self.secp, &new_derivation_path)
+                .derive_xpriv(&new_derivation_path)
                 .expect("derivation path is short")
-                .to_keypair(&self.secp);
-            let beneficiary_key = self
-                .beneficiary_xpub
-                .derive_xpub(&self.secp, &new_derivation_path)?
-                .to_x_only_public_key();
+                .to_keypair();
+            let beneficiary_key =
+                self.beneficiary_xpub.derive_xpub(&new_derivation_path)?.to_x_only_public_key();
 
             // Build up the leaf script and combine with internal key into a Taproot commitment
             let lock_time = absolute::LockTime::from_height(
@@ -505,18 +494,17 @@ impl BenefactorWallet {
 
             let taproot_spend_info = TaprootBuilder::new()
                 .add_leaf(0, script.clone())?
-                .finalize(&self.secp, new_internal_keypair.x_only_public_key().0)
+                .finalize(new_internal_keypair.x_only_public_key().0)
                 .expect("should be finalizable");
             self.current_spend_info = Some(taproot_spend_info.clone());
             let prevout_script_pubkey = input.witness_utxo.as_ref().unwrap().script_pubkey.clone();
-            let output_script_pubkey = ScriptBuf::new_p2tr(
-                &self.secp,
+            let output_script_pubkey = ScriptPubKeyBuf::new_p2tr(
                 taproot_spend_info.internal_key(),
                 taproot_spend_info.merkle_root(),
             );
 
-            psbt.unsigned_tx.output =
-                vec![TxOut { script_pubkey: output_script_pubkey.clone(), value: output_value }];
+            psbt.unsigned_tx.outputs =
+                vec![TxOut { script_pubkey: output_script_pubkey.clone(), amount: output_amount }];
             psbt.outputs = vec![Output::default()];
             psbt.unsigned_tx.lock_time = absolute::LockTime::ZERO;
 
@@ -527,7 +515,7 @@ impl BenefactorWallet {
             let hash = SighashCache::new(&psbt.unsigned_tx).taproot_key_spend_signature_hash(
                 0,
                 &sighash::Prevouts::All(&[TxOut {
-                    value: input_value,
+                    amount: input_amount,
                     script_pubkey: prevout_script_pubkey,
                 }]),
                 sighash_type,
@@ -540,7 +528,7 @@ impl BenefactorWallet {
                     .ok_or("missing Taproot key origin")?;
                 let secret_key = self
                     .master_xpriv
-                    .derive_xpriv(&self.secp, &derivation_path)
+                    .derive_xpriv(derivation_path)
                     .expect("derivation path is short")
                     .to_private_key()
                     .inner;
@@ -551,7 +539,6 @@ impl BenefactorWallet {
                     input,
                     hash,
                     sighash_type,
-                    &self.secp,
                 );
             }
 
@@ -572,20 +559,20 @@ impl BenefactorWallet {
             // EXTRACTOR
             let tx = psbt.extract_tx_unchecked_fee_rate();
             tx.verify(|_| {
-                Some(TxOut { value: input_value, script_pubkey: output_script_pubkey.clone() })
+                Some(TxOut { amount: input_amount, script_pubkey: output_script_pubkey.clone() })
             })
             .expect("failed to verify transaction");
 
             let next_tx = Transaction {
                 version: transaction::Version::TWO,
                 lock_time,
-                input: vec![TxIn {
+                inputs: vec![TxIn {
                     previous_output: OutPoint { txid: tx.compute_txid(), vout: 0 },
-                    script_sig: ScriptBuf::new(),
+                    script_sig: ScriptSigBuf::new(),
                     sequence: bitcoin::Sequence(0xFFFFFFFD), // enable locktime and opt-in RBF
                     witness: Witness::default(),
                 }],
-                output: vec![],
+                outputs: vec![],
             };
             let mut next_psbt = Psbt::from_unsigned_tx(next_tx)?;
             let mut origins = BTreeMap::new();
@@ -605,9 +592,9 @@ impl BenefactorWallet {
             let input = Input {
                 witness_utxo: {
                     let script_pubkey = output_script_pubkey;
-                    let amount = output_value;
+                    let amount = output_amount;
 
-                    Some(TxOut { value: amount, script_pubkey })
+                    Some(TxOut { amount, script_pubkey })
                 },
                 tap_key_origins: origins,
                 tap_merkle_root: taproot_spend_info.merkle_root(),
@@ -632,15 +619,14 @@ impl BenefactorWallet {
 /// after some expiry using CLTV.
 struct BeneficiaryWallet {
     master_xpriv: Xpriv,
-    secp: secp256k1::Secp256k1<secp256k1::All>,
 }
 
 impl BeneficiaryWallet {
     fn new(master_xpriv: Xpriv) -> Result<Self, Box<dyn std::error::Error>> {
-        Ok(Self { master_xpriv, secp: Secp256k1::new() })
+        Ok(Self { master_xpriv })
     }
 
-    fn master_xpub(&self) -> Xpub { Xpub::from_xpriv(&self.secp, &self.master_xpriv) }
+    fn master_xpub(&self) -> Xpub { Xpub::from_xpriv(&self.master_xpriv) }
 
     fn spend_inheritance(
         &self,
@@ -648,13 +634,13 @@ impl BeneficiaryWallet {
         lock_time: absolute::LockTime,
         to_address: Address,
     ) -> Result<Transaction, Box<dyn std::error::Error>> {
-        let input_value = psbt.inputs[0].witness_utxo.as_ref().unwrap().value;
+        let input_amount = psbt.inputs[0].witness_utxo.as_ref().unwrap().amount;
         let input_script_pubkey =
             psbt.inputs[0].witness_utxo.as_ref().unwrap().script_pubkey.clone();
         psbt.unsigned_tx.lock_time = lock_time;
-        psbt.unsigned_tx.output = vec![TxOut {
+        psbt.unsigned_tx.outputs = vec![TxOut {
             script_pubkey: to_address.script_pubkey(),
-            value: (input_value - ABSOLUTE_FEES)
+            amount: (input_amount - ABSOLUTE_FEES)
                 .expect("ABSOLUTE_FEES must be set below input amount"),
         }];
         psbt.outputs = vec![Output::default()];
@@ -664,17 +650,14 @@ impl BeneficiaryWallet {
         for (x_only_pubkey, (leaf_hashes, (_, derivation_path))) in
             &psbt.inputs[0].tap_key_origins.clone()
         {
-            let secret_key = self
-                .master_xpriv
-                .derive_xpriv(&self.secp, &derivation_path)?
-                .to_private_key()
-                .inner;
+            let secret_key =
+                self.master_xpriv.derive_xpriv(derivation_path)?.to_private_key().inner;
             for lh in leaf_hashes {
                 let sighash_type = TapSighashType::All;
                 let hash = SighashCache::new(&unsigned_tx).taproot_script_spend_signature_hash(
                     0,
                     &sighash::Prevouts::All(&[TxOut {
-                        value: input_value,
+                        amount: input_amount,
                         script_pubkey: input_script_pubkey.clone(),
                     }]),
                     *lh,
@@ -687,7 +670,6 @@ impl BeneficiaryWallet {
                     &mut psbt.inputs[0],
                     hash,
                     sighash_type,
-                    &self.secp,
                 );
             }
         }
@@ -718,7 +700,7 @@ impl BeneficiaryWallet {
         // EXTRACTOR
         let tx = psbt.extract_tx_unchecked_fee_rate();
         tx.verify(|_| {
-            Some(TxOut { value: input_value, script_pubkey: input_script_pubkey.clone() })
+            Some(TxOut { amount: input_amount, script_pubkey: input_script_pubkey.clone() })
         })
         .expect("failed to verify transaction");
 
@@ -747,16 +729,14 @@ fn sign_psbt_taproot(
     psbt_input: &mut psbt::Input,
     hash: TapSighash,
     sighash_type: TapSighashType,
-    secp: &Secp256k1<secp256k1::All>,
 ) {
-    let keypair = secp256k1::Keypair::from_seckey_slice(secp, secret_key.as_ref()).unwrap();
+    let keypair = secp256k1::Keypair::from_seckey_byte_array(secret_key.to_secret_bytes()).unwrap();
     let keypair = match leaf_hash {
-        None => keypair.tap_tweak(secp, psbt_input.tap_merkle_root).to_keypair(),
+        None => keypair.tap_tweak(psbt_input.tap_merkle_root).to_keypair(),
         Some(_) => keypair, // no tweak for script spend
     };
 
-    let msg = secp256k1::Message::from(hash);
-    let signature = secp.sign_schnorr(msg.as_ref(), &keypair);
+    let signature = secp256k1::schnorr::sign(&hash.to_byte_array(), &keypair);
 
     let final_signature = taproot::Signature { signature, sighash_type };
 
diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index f1479425c1..822909200f 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -28,12 +28,10 @@ impl From<Infallible> for FromScriptError {
 
 impl fmt::Display for FromScriptError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use FromScriptError::*;
-
-        match *self {
-            WitnessVersion(ref e) => write_err!(f, "witness version construction error"; e),
-            WitnessProgram(ref e) => write_err!(f, "witness program error"; e),
-            UnrecognizedScript => write!(f, "script is not a p2pkh, p2sh or witness program"),
+        match self {
+            Self::WitnessVersion(ref e) => write_err!(f, "witness version construction error"; e),
+            Self::WitnessProgram(ref e) => write_err!(f, "witness program error"; e),
+            Self::UnrecognizedScript => write!(f, "script is not a p2pkh, p2sh or witness program"),
         }
     }
 }
@@ -41,12 +39,10 @@ impl fmt::Display for FromScriptError {
 #[cfg(feature = "std")]
 impl std::error::Error for FromScriptError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use FromScriptError::*;
-
-        match *self {
-            UnrecognizedScript => None,
-            WitnessVersion(ref e) => Some(e),
-            WitnessProgram(ref e) => Some(e),
+        match self {
+            Self::UnrecognizedScript => None,
+            Self::WitnessVersion(ref e) => Some(e),
+            Self::WitnessProgram(ref e) => Some(e),
         }
     }
 }
@@ -93,12 +89,10 @@ impl From<Infallible> for ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseError::*;
-
-        match *self {
-            Base58(ref e) => write_err!(f, "base58 error"; e),
-            Bech32(ref e) => write_err!(f, "bech32 error"; e),
-            NetworkValidation(ref e) => write_err!(f, "validation error"; e),
+        match self {
+            Self::Base58(ref e) => write_err!(f, "base58 error"; e),
+            Self::Bech32(ref e) => write_err!(f, "bech32 error"; e),
+            Self::NetworkValidation(ref e) => write_err!(f, "validation error"; e),
         }
     }
 }
@@ -106,12 +100,10 @@ impl fmt::Display for ParseError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseError::*;
-
-        match *self {
-            Base58(ref e) => Some(e),
-            Bech32(ref e) => Some(e),
-            NetworkValidation(ref e) => Some(e),
+        match self {
+            Self::Base58(ref e) => Some(e),
+            Self::Bech32(ref e) => Some(e),
+            Self::NetworkValidation(ref e) => Some(e),
         }
     }
 }
@@ -125,7 +117,7 @@ impl From<Bech32Error> for ParseError {
 }
 
 impl From<UnknownHrpError> for ParseError {
-    fn from(e: UnknownHrpError) -> ParseError { Self::Bech32(e.into()) }
+    fn from(e: UnknownHrpError) -> Self { Self::Bech32(e.into()) }
 }
 
 impl From<NetworkValidationError> for ParseError {
@@ -186,13 +178,12 @@ impl From<Infallible> for Bech32Error {
 
 impl fmt::Display for Bech32Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Bech32Error::*;
-
-        match *self {
-            ParseBech32(ref e) => write_err!(f, "SegWit parsing error"; e),
-            WitnessVersion(ref e) => write_err!(f, "witness version conversion/parsing error"; e),
-            WitnessProgram(ref e) => write_err!(f, "witness program error"; e),
-            UnknownHrp(ref e) => write_err!(f, "unknown hrp error"; e),
+        match self {
+            Self::ParseBech32(ref e) => write_err!(f, "SegWit parsing error"; e),
+            Self::WitnessVersion(ref e) =>
+                write_err!(f, "witness version conversion/parsing error"; e),
+            Self::WitnessProgram(ref e) => write_err!(f, "witness program error"; e),
+            Self::UnknownHrp(ref e) => write_err!(f, "unknown hrp error"; e),
         }
     }
 }
@@ -200,13 +191,11 @@ impl fmt::Display for Bech32Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Bech32Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Bech32Error::*;
-
-        match *self {
-            ParseBech32(ref e) => Some(e),
-            WitnessVersion(ref e) => Some(e),
-            WitnessProgram(ref e) => Some(e),
-            UnknownHrp(ref e) => Some(e),
+        match self {
+            Self::ParseBech32(ref e) => Some(e),
+            Self::WitnessVersion(ref e) => Some(e),
+            Self::WitnessProgram(ref e) => Some(e),
+            Self::UnknownHrp(ref e) => Some(e),
         }
     }
 }
@@ -263,13 +252,12 @@ impl From<Infallible> for Base58Error {
 
 impl fmt::Display for Base58Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Base58Error::*;
-
-        match *self {
-            ParseBase58(ref e) => write_err!(f, "legacy parsing error"; e),
-            LegacyAddressTooLong(ref e) => write_err!(f, "legacy address length error"; e),
-            InvalidBase58PayloadLength(ref e) => write_err!(f, "legacy payload length error"; e),
-            InvalidLegacyPrefix(ref e) => write_err!(f, "legacy prefix error"; e),
+        match self {
+            Self::ParseBase58(ref e) => write_err!(f, "legacy parsing error"; e),
+            Self::LegacyAddressTooLong(ref e) => write_err!(f, "legacy address length error"; e),
+            Self::InvalidBase58PayloadLength(ref e) =>
+                write_err!(f, "legacy payload length error"; e),
+            Self::InvalidLegacyPrefix(ref e) => write_err!(f, "legacy prefix error"; e),
         }
     }
 }
@@ -277,13 +265,11 @@ impl fmt::Display for Base58Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Base58Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Base58Error::*;
-
-        match *self {
-            ParseBase58(ref e) => Some(e),
-            LegacyAddressTooLong(ref e) => Some(e),
-            InvalidBase58PayloadLength(ref e) => Some(e),
-            InvalidLegacyPrefix(ref e) => Some(e),
+        match self {
+            Self::ParseBase58(ref e) => Some(e),
+            Self::LegacyAddressTooLong(ref e) => Some(e),
+            Self::InvalidBase58PayloadLength(ref e) => Some(e),
+            Self::InvalidLegacyPrefix(ref e) => Some(e),
         }
     }
 }
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index c2a0b1a75b..709d108ea4 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -9,13 +9,12 @@
 //! ### Creating a new address from a randomly-generated key pair.
 //!
 //! ```rust
-//! #[cfg(feature = "rand-std")] {
-//! use bitcoin::secp256k1::{rand, Secp256k1};
+//! #[cfg(all(feature = "rand", feature = "std"))] {
+//! use bitcoin::secp256k1::rand;
 //! use bitcoin::{Address, Network, PublicKey};
 //!
 //! // Generate random key pair.
-//! let secp = Secp256k1::new();
-//! let (_sk, pk) = secp.generate_keypair(&mut rand::thread_rng());
+//! let (_sk, pk) = secp256k1::generate_keypair(&mut rand::rng());
 //! let public_key = PublicKey::new(pk); // Or `PublicKey::from(pk)`.
 //!
 //! // Generate a mainnet pay-to-pubkey-hash address.
@@ -40,7 +39,6 @@
 //! ```
 
 pub mod error;
-pub mod script_pubkey;
 
 use core::fmt;
 use core::marker::PhantomData;
@@ -50,9 +48,7 @@ use bech32::primitives::gf32::Fe32;
 use bech32::primitives::hrp::Hrp;
 use hashes::{hash160, HashEngine};
 use internals::array::ArrayExt;
-use secp256k1::{Secp256k1, Verification};
 
-use crate::address::script_pubkey::ScriptBufExt as _;
 use crate::constants::{
     PUBKEY_ADDRESS_PREFIX_MAIN, PUBKEY_ADDRESS_PREFIX_TEST, SCRIPT_ADDRESS_PREFIX_MAIN,
     SCRIPT_ADDRESS_PREFIX_TEST,
@@ -66,8 +62,9 @@ use crate::prelude::{String, ToOwned};
 use crate::script::witness_program::WitnessProgram;
 use crate::script::witness_version::WitnessVersion;
 use crate::script::{
-    self, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash, WScriptHash,
-    WitnessScriptSizeError,
+    self, RedeemScriptSizeError, Script, ScriptExt as _, ScriptHash, ScriptHashableTag,
+    ScriptPubKey, ScriptPubKeyBuf, ScriptPubKeyBufExt as _, ScriptPubKeyExt as _, WScriptHash,
+    WitnessScript, WitnessScriptExt as _, WitnessScriptSizeError,
 };
 use crate::taproot::TapNodeHash;
 
@@ -100,12 +97,12 @@ pub enum AddressType {
 impl fmt::Display for AddressType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match *self {
-            AddressType::P2pkh => "p2pkh",
-            AddressType::P2sh => "p2sh",
-            AddressType::P2wpkh => "p2wpkh",
-            AddressType::P2wsh => "p2wsh",
-            AddressType::P2tr => "p2tr",
-            AddressType::P2a => "p2a",
+            Self::P2pkh => "p2pkh",
+            Self::P2sh => "p2sh",
+            Self::P2wpkh => "p2wpkh",
+            Self::P2wsh => "p2wsh",
+            Self::P2tr => "p2tr",
+            Self::P2a => "p2a",
         })
     }
 }
@@ -114,12 +111,12 @@ impl FromStr for AddressType {
     type Err = UnknownAddressTypeError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "p2pkh" => Ok(AddressType::P2pkh),
-            "p2sh" => Ok(AddressType::P2sh),
-            "p2wpkh" => Ok(AddressType::P2wpkh),
-            "p2wsh" => Ok(AddressType::P2wsh),
-            "p2tr" => Ok(AddressType::P2tr),
-            "p2a" => Ok(AddressType::P2a),
+            "p2pkh" => Ok(Self::P2pkh),
+            "p2sh" => Ok(Self::P2sh),
+            "p2wpkh" => Ok(Self::P2wpkh),
+            "p2wsh" => Ok(Self::P2wsh),
+            "p2tr" => Ok(Self::P2tr),
+            "p2a" => Ok(Self::P2a),
             _ => Err(UnknownAddressTypeError(s.to_owned())),
         }
     }
@@ -280,9 +277,9 @@ impl From<Network> for KnownHrp {
 impl From<KnownHrp> for NetworkKind {
     fn from(hrp: KnownHrp) -> Self {
         match hrp {
-            KnownHrp::Mainnet => NetworkKind::Main,
-            KnownHrp::Testnets => NetworkKind::Test,
-            KnownHrp::Regtest => NetworkKind::Test,
+            KnownHrp::Mainnet => Self::Main,
+            KnownHrp::Testnets => Self::Test,
+            KnownHrp::Regtest => Self::Test,
         }
     }
 }
@@ -328,7 +325,7 @@ internals::transparent_newtype! {
     /// can be called, providing network on which the address is supposed to be valid. If the verification succeeds,
     /// `Address<NetworkChecked>` is returned.
     ///
-    /// The types `Address` and `Address<NetworkChecked>` are synonymous, i. e. they can be used interchangeably.
+    /// The types `Address` and `Address<NetworkChecked>` are synonymous, i.e. they can be used interchangeably.
     ///
     /// ```rust
     /// use std::str::FromStr;
@@ -389,12 +386,12 @@ internals::transparent_newtype! {
     ///
     /// # Relevant BIPs
     ///
-    /// * [BIP13 - Address Format for pay-to-script-hash](https://github.com/bitcoin/bips/blob/master/bip-0013.mediawiki)
-    /// * [BIP16 - Pay to Script Hash](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki)
-    /// * [BIP141 - Segregated Witness (Consensus layer)](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
-    /// * [BIP142 - Address Format for Segregated Witness](https://github.com/bitcoin/bips/blob/master/bip-0142.mediawiki)
-    /// * [BIP341 - Taproot: SegWit version 1 spending rules](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)
-    /// * [BIP350 - Bech32m format for v1+ witness addresses](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki)
+    /// * [BIP-0013 - Address Format for pay-to-script-hash](https://github.com/bitcoin/bips/blob/master/bip-0013.mediawiki)
+    /// * [BIP-0016 - Pay to Script Hash](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki)
+    /// * [BIP-0141 - Segregated Witness (Consensus layer)](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    /// * [BIP-0142 - Address Format for Segregated Witness](https://github.com/bitcoin/bips/blob/master/bip-0142.mediawiki)
+    /// * [BIP-0341 - Taproot: SegWit version 1 spending rules](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)
+    /// * [BIP-0350 - Bech32m format for v1+ witness addresses](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki)
     #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
     // The `#[repr(transparent)]` attribute is used to guarantee the layout of the `Address` struct. It
     // is an implementation detail and users should not rely on it in their code.
@@ -419,7 +416,7 @@ impl<N: NetworkValidation> fmt::Display for DisplayUnchecked<'_, N> {
 
 #[cfg(feature = "serde")]
 impl<'de, U: NetworkValidationUnchecked> serde::Deserialize<'de> for Address<U> {
-    fn deserialize<D>(deserializer: D) -> Result<Address<U>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::de::Deserializer<'de>,
     {
@@ -443,7 +440,7 @@ impl<'de, U: NetworkValidationUnchecked> serde::Deserialize<'de> for Address<U>
             {
                 // We know that `U` is only ever `NetworkUnchecked` but the compiler does not.
                 let address = v.parse::<Address<NetworkUnchecked>>().map_err(E::custom)?;
-                Ok(Address::from_inner(address.into_inner()))
+                Ok(Address::from_inner(address.to_inner()))
             }
         }
 
@@ -464,9 +461,9 @@ impl<V: NetworkValidation> serde::Serialize for Address<V> {
 /// Methods on [`Address`] that can be called on both `Address<NetworkChecked>` and
 /// `Address<NetworkUnchecked>`.
 impl<V: NetworkValidation> Address<V> {
-    fn from_inner(inner: AddressInner) -> Self { Address(PhantomData, inner) }
+    fn from_inner(inner: AddressInner) -> Self { Self(PhantomData, inner) }
 
-    fn into_inner(self) -> AddressInner { self.1 }
+    fn to_inner(self) -> AddressInner { self.1 }
 
     fn inner(&self) -> &AddressInner { &self.1 }
 
@@ -476,8 +473,12 @@ impl<V: NetworkValidation> Address<V> {
     }
 
     /// Marks the network of this address as unchecked.
+    pub fn to_unchecked(self) -> Address<NetworkUnchecked> { Address::from_inner(self.to_inner()) }
+
+    /// Marks the network of this address as unchecked.
+    #[deprecated(since = "0.33.0", note = "use to_unchecked instead")]
     pub fn into_unchecked(self) -> Address<NetworkUnchecked> {
-        Address::from_inner(self.into_inner())
+        Address::from_inner(self.to_inner())
     }
 
     /// Returns the [`NetworkKind`] of this address.
@@ -497,22 +498,22 @@ impl Address {
     ///
     /// This is the preferred non-witness type address.
     #[inline]
-    pub fn p2pkh(pk: impl Into<PubkeyHash>, network: impl Into<NetworkKind>) -> Address {
+    pub fn p2pkh(pk: impl Into<PubkeyHash>, network: impl Into<NetworkKind>) -> Self {
         let hash = pk.into();
         Self::from_inner(AddressInner::P2pkh { hash, network: network.into() })
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] from a script.
     ///
-    /// This address type was introduced with BIP16 and is the popular type to implement multi-sig
+    /// This address type was introduced with BIP-0016 and is the popular type to implement multi-sig
     /// these days.
     #[inline]
-    pub fn p2sh(
-        redeem_script: &Script,
+    pub fn p2sh<T: ScriptHashableTag>(
+        redeem_script: &Script<T>,
         network: impl Into<NetworkKind>,
-    ) -> Result<Address, RedeemScriptSizeError> {
+    ) -> Result<Self, RedeemScriptSizeError> {
         let hash = redeem_script.script_hash()?;
-        Ok(Address::p2sh_from_hash(hash, network))
+        Ok(Self::p2sh_from_hash(hash, network))
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] from a script hash.
@@ -521,7 +522,7 @@ impl Address {
     ///
     /// The `hash` pre-image (redeem script) must not exceed 520 bytes in length
     /// otherwise outputs created from the returned address will be un-spendable.
-    pub fn p2sh_from_hash(hash: ScriptHash, network: impl Into<NetworkKind>) -> Address {
+    pub fn p2sh_from_hash(hash: ScriptHash, network: impl Into<NetworkKind>) -> Self {
         Self::from_inner(AddressInner::P2sh { hash, network: network.into() })
     }
 
@@ -530,32 +531,32 @@ impl Address {
     /// This is the native SegWit address type for an output redeemable with a single signature.
     pub fn p2wpkh(pk: CompressedPublicKey, hrp: impl Into<KnownHrp>) -> Self {
         let program = WitnessProgram::p2wpkh(pk);
-        Address::from_witness_program(program, hrp)
+        Self::from_witness_program(program, hrp)
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
     /// pay-to-witness-public-key-hash (P2WPKH).
     ///
     /// This is a SegWit address type that looks familiar (as p2sh) to legacy clients.
-    pub fn p2shwpkh(pk: CompressedPublicKey, network: impl Into<NetworkKind>) -> Address {
-        let builder = script::Builder::new().push_int_unchecked(0).push_slice(pk.wpubkey_hash());
+    pub fn p2shwpkh(pk: CompressedPublicKey, network: impl Into<NetworkKind>) -> Self {
+        let builder = ScriptPubKey::builder().push_int_unchecked(0).push_slice(pk.wpubkey_hash());
         let script_hash = builder.as_script().script_hash().expect("script is less than 520 bytes");
-        Address::p2sh_from_hash(script_hash, network)
+        Self::p2sh_from_hash(script_hash, network)
     }
 
     /// Constructs a new pay-to-witness-script-hash (P2WSH) [`Address`] from a witness script.
     pub fn p2wsh(
-        witness_script: &Script,
+        witness_script: &WitnessScript,
         hrp: impl Into<KnownHrp>,
-    ) -> Result<Address, WitnessScriptSizeError> {
+    ) -> Result<Self, WitnessScriptSizeError> {
         let program = WitnessProgram::p2wsh(witness_script)?;
-        Ok(Address::from_witness_program(program, hrp))
+        Ok(Self::from_witness_program(program, hrp))
     }
 
     /// Constructs a new pay-to-witness-script-hash (P2WSH) [`Address`] from a witness script hash.
-    pub fn p2wsh_from_hash(hash: WScriptHash, hrp: impl Into<KnownHrp>) -> Address {
+    pub fn p2wsh_from_hash(hash: WScriptHash, hrp: impl Into<KnownHrp>) -> Self {
         let program = WitnessProgram::p2wsh_from_hash(hash);
-        Address::from_witness_program(program, hrp)
+        Self::from_witness_program(program, hrp)
     }
 
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
@@ -563,40 +564,44 @@ impl Address {
     ///
     /// This is a SegWit address type that looks familiar (as p2sh) to legacy clients.
     pub fn p2shwsh(
-        witness_script: &Script,
+        witness_script: &WitnessScript,
         network: impl Into<NetworkKind>,
-    ) -> Result<Address, WitnessScriptSizeError> {
+    ) -> Result<Self, WitnessScriptSizeError> {
         let hash = witness_script.wscript_hash()?;
-        let builder = script::Builder::new().push_int_unchecked(0).push_slice(hash);
+        let builder = ScriptPubKey::builder().push_int_unchecked(0).push_slice(hash);
         let script_hash = builder.as_script().script_hash().expect("script is less than 520 bytes");
-        Ok(Address::p2sh_from_hash(script_hash, network))
+        Ok(Self::p2sh_from_hash(script_hash, network))
     }
 
     /// Constructs a new pay-to-Taproot (P2TR) [`Address`] from an untweaked key.
-    pub fn p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
-        secp: &Secp256k1<C>,
+    pub fn p2tr<K: Into<UntweakedPublicKey>>(
         internal_key: K,
         merkle_root: Option<TapNodeHash>,
         hrp: impl Into<KnownHrp>,
-    ) -> Address {
+    ) -> Self {
         let internal_key = internal_key.into();
-        let program = WitnessProgram::p2tr(secp, internal_key, merkle_root);
-        Address::from_witness_program(program, hrp)
+        let program = WitnessProgram::p2tr(internal_key, merkle_root);
+        Self::from_witness_program(program, hrp)
     }
 
     /// Constructs a new pay-to-Taproot (P2TR) [`Address`] from a pre-tweaked output key.
-    pub fn p2tr_tweaked(output_key: TweakedPublicKey, hrp: impl Into<KnownHrp>) -> Address {
+    pub fn p2tr_tweaked(output_key: TweakedPublicKey, hrp: impl Into<KnownHrp>) -> Self {
         let program = WitnessProgram::p2tr_tweaked(output_key);
-        Address::from_witness_program(program, hrp)
+        Self::from_witness_program(program, hrp)
+    }
+
+    /// Constructs a new pay-to-anchor (P2A) [`Address`].
+    pub fn p2a(hrp: impl Into<KnownHrp>) -> Self {
+        Self::from_witness_program(WitnessProgram::p2a(), hrp)
     }
 
     /// Constructs a new [`Address`] from an arbitrary [`WitnessProgram`].
     ///
     /// This only exists to support future witness versions. If you are doing normal mainnet things
     /// then you likely do not need this constructor.
-    pub fn from_witness_program(program: WitnessProgram, hrp: impl Into<KnownHrp>) -> Address {
+    pub fn from_witness_program(program: WitnessProgram, hrp: impl Into<KnownHrp>) -> Self {
         let inner = AddressInner::Segwit { program, hrp: hrp.into() };
-        Address::from_inner(inner)
+        Self::from_inner(inner)
     }
 
     /// Gets the address type of the [`Address`].
@@ -682,39 +687,39 @@ impl Address {
 
     /// Constructs a new [`Address`] from an output script (`scriptPubkey`).
     pub fn from_script(
-        script: &Script,
+        script: &ScriptPubKey,
         params: impl AsRef<Params>,
-    ) -> Result<Address, FromScriptError> {
+    ) -> Result<Self, FromScriptError> {
         let network = params.as_ref().network;
         if script.is_p2pkh() {
             let bytes = script.as_bytes()[3..23].try_into().expect("statically 20B long");
             let hash = PubkeyHash::from_byte_array(bytes);
-            Ok(Address::p2pkh(hash, network))
+            Ok(Self::p2pkh(hash, network))
         } else if script.is_p2sh() {
             let bytes = script.as_bytes()[2..22].try_into().expect("statically 20B long");
             let hash = ScriptHash::from_byte_array(bytes);
-            Ok(Address::p2sh_from_hash(hash, network))
+            Ok(Self::p2sh_from_hash(hash, network))
         } else if script.is_witness_program() {
             let opcode = script.first_opcode().expect("is_witness_program guarantees len > 4");
 
             let version = WitnessVersion::try_from(opcode)?;
             let program = WitnessProgram::new(version, &script.as_bytes()[2..])?;
-            Ok(Address::from_witness_program(program, network))
+            Ok(Self::from_witness_program(program, network))
         } else {
             Err(FromScriptError::UnrecognizedScript)
         }
     }
 
     /// Generates a script pubkey spending to this address.
-    pub fn script_pubkey(&self) -> ScriptBuf {
+    pub fn script_pubkey(&self) -> ScriptPubKeyBuf {
         use AddressInner::*;
         match *self.inner() {
-            P2pkh { hash, network: _ } => ScriptBuf::new_p2pkh(hash),
-            P2sh { hash, network: _ } => ScriptBuf::new_p2sh(hash),
+            P2pkh { hash, network: _ } => ScriptPubKeyBuf::new_p2pkh(hash),
+            P2sh { hash, network: _ } => ScriptPubKeyBuf::new_p2sh(hash),
             Segwit { ref program, hrp: _ } => {
                 let prog = program.program();
                 let version = program.version();
-                script_pubkey::new_witness_program_unchecked(version, prog)
+                script::new_witness_program_unchecked(version, prog)
             }
         }
     }
@@ -727,7 +732,7 @@ impl Address {
     /// Quoting BIP 173 "inside QR codes uppercase SHOULD be used, as those permit the use of
     /// alphanumeric mode, which is 45% more compact than the normal byte mode."
     ///
-    /// Note however that despite BIP21 explicitly stating that the `bitcoin:` prefix should be
+    /// Note however that despite BIP-0021 explicitly stating that the `bitcoin:` prefix should be
     /// parsed as case-insensitive many wallets got this wrong and don't parse correctly.
     /// [See compatibility table.](https://github.com/btcpayserver/btcpayserver/issues/2110)
     ///
@@ -773,7 +778,7 @@ impl Address {
 
     /// Returns true if the address creates a particular script
     /// This function doesn't make any allocations.
-    pub fn matches_script_pubkey(&self, script: &Script) -> bool {
+    pub fn matches_script_pubkey(&self, script: &ScriptPubKey) -> bool {
         use AddressInner::*;
         match *self.inner() {
             P2pkh { ref hash, network: _ } if script.is_p2pkh() =>
@@ -899,10 +904,10 @@ impl Address<NetworkUnchecked> {
     /// For details about this mechanism, see section [*Parsing addresses*](Address#parsing-addresses)
     /// on [`Address`].
     #[inline]
-    pub fn assume_checked(self) -> Address { Address::from_inner(self.into_inner()) }
+    pub fn assume_checked(self) -> Address { Address::from_inner(self.to_inner()) }
 
-    /// Parse a bech32 Address string
-    pub fn from_bech32_str(s: &str) -> Result<Address<NetworkUnchecked>, Bech32Error> {
+    /// Parses a bech32 Address string
+    pub fn from_bech32_str(s: &str) -> Result<Self, Bech32Error> {
         let (hrp, witness_version, data) =
             bech32::segwit::decode(s).map_err(|e| Bech32Error::ParseBech32(ParseBech32Error(e)))?;
         let version = WitnessVersion::try_from(witness_version.to_u8())?;
@@ -911,17 +916,18 @@ impl Address<NetworkUnchecked> {
 
         let hrp = KnownHrp::from_hrp(hrp)?;
         let inner = AddressInner::Segwit { program, hrp };
-        Ok(Address::from_inner(inner))
+        Ok(Self::from_inner(inner))
     }
 
-    /// Parse a base58 Address string
-    pub fn from_base58_str(s: &str) -> Result<Address<NetworkUnchecked>, Base58Error> {
+    /// Parses a base58 Address string
+    pub fn from_base58_str(s: &str) -> Result<Self, Base58Error> {
         if s.len() > 50 {
             return Err(LegacyAddressTooLongError { length: s.len() }.into());
         }
         let data = base58::decode_check(s)?;
-        let data: &[u8; 21] =
-            (&*data).try_into().map_err(|_| InvalidBase58PayloadLengthError { length: s.len() })?;
+        let data: &[u8; 21] = (&*data)
+            .try_into()
+            .map_err(|_| InvalidBase58PayloadLengthError { length: data.len() })?;
 
         let (prefix, &data) = data.split_first();
 
@@ -945,15 +951,15 @@ impl Address<NetworkUnchecked> {
             invalid => return Err(InvalidLegacyPrefixError { invalid }.into()),
         };
 
-        Ok(Address::from_inner(inner))
+        Ok(Self::from_inner(inner))
     }
 }
 
-impl From<Address> for ScriptBuf {
+impl From<Address> for ScriptPubKeyBuf {
     fn from(a: Address) -> Self { a.script_pubkey() }
 }
 
-// Alternate formatting `{:#}` is used to return uppercase version of bech32 addresses which should
+// Alternate formatting `{:#}` is used to return an uppercase version of bech32 addresses which should
 // be used in QR codes, see [`Address::to_qr_uri`].
 impl fmt::Display for Address {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.inner(), fmt) }
@@ -993,10 +999,10 @@ impl<U: NetworkValidationUnchecked> FromStr for Address<U> {
         if ["bc1", "bcrt1", "tb1"].iter().any(|&prefix| s.to_lowercase().starts_with(prefix)) {
             let address = Address::from_bech32_str(s)?;
             // We know that `U` is only ever `NetworkUnchecked` but the compiler does not.
-            Ok(Address::from_inner(address.into_inner()))
+            Ok(Self::from_inner(address.to_inner()))
         } else if ["1", "2", "3", "m", "n"].iter().any(|&prefix| s.starts_with(prefix)) {
             let address = Address::from_base58_str(s)?;
-            Ok(Address::from_inner(address.into_inner()))
+            Ok(Self::from_inner(address.to_inner()))
         } else {
             let hrp = match s.rfind('1') {
                 Some(pos) => &s[..pos],
@@ -1022,7 +1028,7 @@ mod tests {
     use super::*;
     use crate::network::Network::{Bitcoin, Testnet};
     use crate::network::{params, TestnetVersion};
-    use crate::script::ScriptBufExt as _;
+    use crate::script::{RedeemScriptBuf, ScriptBufExt as _, WitnessScriptBuf};
 
     fn roundtrips(addr: &Address, network: Network) {
         assert_eq!(
@@ -1055,7 +1061,7 @@ mod tests {
 
         assert_eq!(
             addr.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix(
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac"
             )
             .unwrap()
@@ -1087,8 +1093,10 @@ mod tests {
 
         assert_eq!(
             addr.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
-                .unwrap(),
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
+                "a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087"
+            )
+            .unwrap(),
         );
         assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
@@ -1097,7 +1105,7 @@ mod tests {
 
     #[test]
     fn p2sh_parse() {
-        let script = ScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae").unwrap();
+        let script = RedeemScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae").unwrap();
         let addr = Address::p2sh(&script, NetworkKind::Test).unwrap();
         assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
@@ -1106,7 +1114,7 @@ mod tests {
 
     #[test]
     fn p2sh_parse_for_large_script() {
-        let script = ScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
+        let script = RedeemScriptBuf::from_hex_no_length_prefix("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
         let res = Address::p2sh(&script, NetworkKind::Test);
         assert_eq!(res.unwrap_err().invalid_size(), script.len())
     }
@@ -1126,7 +1134,7 @@ mod tests {
     #[test]
     fn p2wsh() {
         // stolen from Bitcoin transaction 5df912fda4becb1c29e928bec8d64d93e9ba8efa9b5b405bd683c86fd2c65667
-        let script = ScriptBuf::from_hex_no_length_prefix("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae").unwrap();
+        let script = WitnessScriptBuf::from_hex_no_length_prefix("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae").unwrap();
         let addr = Address::p2wsh(&script, KnownHrp::Mainnet).expect("script is valid");
         assert_eq!(
             &addr.to_string(),
@@ -1151,7 +1159,7 @@ mod tests {
     #[test]
     fn p2shwsh() {
         // stolen from Bitcoin transaction f9ee2be4df05041d0e0a35d7caa3157495ca4f93b233234c9967b6901dacf7a9
-        let script = ScriptBuf::from_hex_no_length_prefix("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae").unwrap();
+        let script = WitnessScriptBuf::from_hex_no_length_prefix("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae").unwrap();
         let addr = Address::p2shwsh(&script, NetworkKind::Main).expect("script is valid");
         assert_eq!(&addr.to_string(), "36EqgNnsWW94SreZgBWc1ANC6wpFZwirHr");
         assert_eq!(addr.address_type(), Some(AddressType::P2sh));
@@ -1240,7 +1248,7 @@ mod tests {
         assert_eq!(addr.to_string(), into.to_string());
         assert_eq!(
             into.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix(
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac"
             )
             .unwrap()
@@ -1257,8 +1265,10 @@ mod tests {
         assert_eq!(addr.to_string(), into.to_string());
         assert_eq!(
             into.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
-                .unwrap()
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
+                "a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087"
+            )
+            .unwrap()
         );
 
         let addr: Address<NetworkUnchecked> =
@@ -1288,7 +1298,7 @@ mod tests {
         assert_eq!(addr.to_string(), into.to_string());
         assert_eq!(
             into.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix(
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262"
             )
             .unwrap()
@@ -1307,8 +1317,10 @@ mod tests {
         assert_eq!(addr.to_string(), into.to_string());
         assert_eq!(
             into.script_pubkey(),
-            ScriptBuf::from_hex_no_length_prefix("001454d26dddb59c7073c6a197946ea1841951fa7a74")
-                .unwrap()
+            ScriptPubKeyBuf::from_hex_no_length_prefix(
+                "001454d26dddb59c7073c6a197946ea1841951fa7a74"
+            )
+            .unwrap()
         );
     }
 
@@ -1342,8 +1354,7 @@ mod tests {
         let internal_key = "cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115"
             .parse::<XOnlyPublicKey>()
             .unwrap();
-        let secp = Secp256k1::verification_only();
-        let address = Address::p2tr(&secp, internal_key, None, KnownHrp::Mainnet);
+        let address = Address::p2tr(internal_key, None, KnownHrp::Mainnet);
         assert_eq!(
             address.to_string(),
             "bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr"
@@ -1487,15 +1498,17 @@ mod tests {
     fn fail_address_from_script() {
         use crate::witness_program;
 
-        let bad_p2wpkh =
-            ScriptBuf::from_hex_no_length_prefix("15000014dbc5b0a8f9d4353b4b54c3db48846bb15abfec")
-                .unwrap();
-        let bad_p2wsh = ScriptBuf::from_hex_no_length_prefix(
+        let bad_p2wpkh = ScriptPubKeyBuf::from_hex_no_length_prefix(
+            "15000014dbc5b0a8f9d4353b4b54c3db48846bb15abfec",
+        )
+        .unwrap();
+        let bad_p2wsh = ScriptPubKeyBuf::from_hex_no_length_prefix(
             "00202d4fa2eb233d008cc83206fa2f4f2e60199000f5b857a835e3172323385623",
         )
         .unwrap();
         let invalid_segwitv0_script =
-            ScriptBuf::from_hex_no_length_prefix("001161458e330389cd0437ee9fe3641d70cc18").unwrap();
+            ScriptPubKeyBuf::from_hex_no_length_prefix("001161458e330389cd0437ee9fe3641d70cc18")
+                .unwrap();
         let expected = Err(FromScriptError::UnrecognizedScript);
 
         assert_eq!(Address::from_script(&bad_p2wpkh, Network::Bitcoin), expected);
@@ -1565,17 +1578,17 @@ mod tests {
         // Serialize with an unchecked address.
         let foo_unchecked = Foo { address: unchecked };
         let ser = serde_json::to_string(&foo_unchecked).expect("failed to serialize");
-        let rinsed: Foo<NetworkUnchecked> =
+        let roundtrip: Foo<NetworkUnchecked> =
             serde_json::from_str(&ser).expect("failed to deserialize");
-        assert_eq!(rinsed, foo_unchecked);
+        assert_eq!(roundtrip, foo_unchecked);
 
         // Serialize with a checked address.
         let foo_checked = Foo { address: unchecked.assume_checked() };
         let ser = serde_json::to_string(&foo_checked).expect("failed to serialize");
-        let rinsed: Foo<NetworkUnchecked> =
+        let roundtrip: Foo<NetworkUnchecked> =
             serde_json::from_str(&ser).expect("failed to deserialize");
-        assert_eq!(&rinsed.address, foo_checked.address.as_unchecked());
-        assert_eq!(rinsed, foo_unchecked);
+        assert_eq!(&roundtrip.address, foo_checked.address.as_unchecked());
+        assert_eq!(roundtrip, foo_unchecked);
     }
 
     #[test]
@@ -1584,7 +1597,7 @@ mod tests {
         // This test-vector is borrowed from the bitcoin source code.
         let address_str = "bcrt1pfeesnyr2tx";
 
-        let script = ScriptBuf::new_p2a();
+        let script = ScriptPubKeyBuf::new_p2a();
         let address_unchecked = address_str.parse().unwrap();
         let address = Address::from_script(&script, Network::Regtest).unwrap();
         assert_eq!(address.as_unchecked(), &address_unchecked);
@@ -1595,4 +1608,22 @@ mod tests {
         assert!(address.is_spend_standard());
         assert_eq!(address.address_type(), Some(AddressType::P2a));
     }
+
+    #[test]
+    fn base58_invalid_payload_length_reports_decoded_size() {
+        use crate::constants::PUBKEY_ADDRESS_PREFIX_MAIN;
+
+        let mut payload = [0u8; 22]; // Invalid: should be 21
+        payload[0] = PUBKEY_ADDRESS_PREFIX_MAIN;
+        let encoded = base58::encode_check(&payload);
+
+        let err = Address::<NetworkUnchecked>::from_base58_str(&encoded).unwrap_err();
+        match err {
+            Base58Error::InvalidBase58PayloadLength(inner) => {
+                assert_eq!(inner.invalid_base58_payload_length(), 22); // Payload size
+                assert_ne!(inner.invalid_base58_payload_length(), encoded.len()); // Not string size
+            }
+            other => panic!("unexpected error: {other:?}"),
+        }
+    }
 }
diff --git a/bitcoin/src/address/script_pubkey.rs b/bitcoin/src/address/script_pubkey.rs
deleted file mode 100644
index bc3637de3b..0000000000
--- a/bitcoin/src/address/script_pubkey.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin scriptPubkey script extensions.
-
-use internals::array::ArrayExt;
-use secp256k1::{Secp256k1, Verification};
-
-use crate::internal_macros::define_extension_trait;
-use crate::key::{
-    PubkeyHash, PublicKey, TapTweak, TweakedPublicKey, UntweakedPublicKey, WPubkeyHash,
-    XOnlyPublicKey,
-};
-use crate::opcodes::all::*;
-use crate::script::witness_program::{WitnessProgram, P2A_PROGRAM};
-use crate::script::witness_version::WitnessVersion;
-use crate::script::{
-    self, Builder, PushBytes, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash,
-    WScriptHash, WitnessScriptSizeError,
-};
-use crate::taproot::TapNodeHash;
-
-define_extension_trait! {
-    /// Extension functionality to add scriptPubkey support to the [`Builder`] type.
-    pub trait BuilderExt impl for Builder {
-        /// Adds instructions to push a public key onto the stack.
-        fn push_key(self, key: PublicKey) -> Builder {
-            if key.compressed {
-                self.push_slice(key.inner.serialize())
-            } else {
-                self.push_slice(key.inner.serialize_uncompressed())
-            }
-        }
-
-        /// Adds instructions to push an XOnly public key onto the stack.
-        fn push_x_only_key(self, x_only_key: XOnlyPublicKey) -> Builder {
-            self.push_slice(x_only_key.serialize())
-        }
-    }
-}
-
-define_extension_trait! {
-    /// Extension functionality to add scriptPubkey support to the [`Script`] type.
-    pub trait ScriptExt impl for Script {
-        /// Computes the P2WSH output corresponding to this witnessScript (aka the "witness redeem
-        /// script").
-        fn to_p2wsh(&self) -> Result<ScriptBuf, WitnessScriptSizeError> {
-            self.wscript_hash().map(ScriptBuf::new_p2wsh)
-        }
-
-        /// Computes P2TR output with a given internal key and a single script spending path equal to
-        /// the current script, assuming that the script is a Tapscript.
-        fn to_p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
-            &self,
-            secp: &Secp256k1<C>,
-            internal_key: K,
-        ) -> ScriptBuf {
-            let internal_key = internal_key.into();
-            let leaf_hash = self.tapscript_leaf_hash();
-            let merkle_root = TapNodeHash::from(leaf_hash);
-            ScriptBuf::new_p2tr(secp, internal_key, Some(merkle_root))
-        }
-
-        /// Computes the P2SH output corresponding to this redeem script.
-        fn to_p2sh(&self) -> Result<ScriptBuf, RedeemScriptSizeError> {
-            self.script_hash().map(ScriptBuf::new_p2sh)
-        }
-
-        /// Returns the script code used for spending a P2WPKH output if this script is a script pubkey
-        /// for a P2WPKH output. The `scriptCode` is described in [BIP143].
-        ///
-        /// [BIP143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
-        fn p2wpkh_script_code(&self) -> Option<ScriptBuf> {
-            if self.is_p2wpkh() {
-                // The `self` script is 0x00, 0x14, <pubkey_hash>
-                let bytes = <[u8; 20]>::try_from(&self.as_bytes()[2..]).expect("length checked in is_p2wpkh()");
-                let wpkh = WPubkeyHash::from_byte_array(bytes);
-                Some(script::p2wpkh_script_code(wpkh))
-            } else {
-                None
-            }
-        }
-
-        /// Checks whether a script pubkey is a P2PK output.
-        ///
-        /// You can obtain the public key, if its valid,
-        /// by calling [`p2pk_public_key()`](Self::p2pk_public_key)
-        fn is_p2pk(&self) -> bool { self.p2pk_pubkey_bytes().is_some() }
-
-        /// Returns the public key if this script is P2PK with a **valid** public key.
-        ///
-        /// This may return `None` even when [`is_p2pk()`](Self::is_p2pk) returns true.
-        /// This happens when the public key is invalid (e.g. the point not being on the curve).
-        /// In this situation the script is unspendable.
-        fn p2pk_public_key(&self) -> Option<PublicKey> {
-            PublicKey::from_slice(self.p2pk_pubkey_bytes()?).ok()
-        }
-    }
-}
-
-define_extension_trait! {
-    pub(crate) trait ScriptExtPrivate impl for Script {
-        /// Returns the bytes of the (possibly invalid) public key if this script is P2PK.
-        fn p2pk_pubkey_bytes(&self) -> Option<&[u8]> {
-            if let Ok(bytes) = <&[u8; 67]>::try_from(self.as_bytes()) {
-                let (&first, bytes) = bytes.split_first::<66>();
-                let (&last, pubkey) = bytes.split_last::<65>();
-                (first == OP_PUSHBYTES_65.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
-            } else if let Ok(bytes) = <&[u8; 35]>::try_from(self.as_bytes()) {
-                let (&first, bytes) = bytes.split_first::<34>();
-                let (&last, pubkey) = bytes.split_last::<33>();
-                (first == OP_PUSHBYTES_33.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
-            } else {
-                None
-            }
-        }
-    }
-}
-
-define_extension_trait! {
-    /// Extension functionality to add scriptPubkey support to the [`ScriptBuf`] type.
-    pub trait ScriptBufExt impl for ScriptBuf {
-        /// Generates P2PK-type of scriptPubkey.
-        fn new_p2pk(pubkey: PublicKey) -> Self {
-            Builder::new().push_key(pubkey).push_opcode(OP_CHECKSIG).into_script()
-        }
-
-        /// Generates P2PKH-type of scriptPubkey.
-        fn new_p2pkh(pubkey_hash: PubkeyHash) -> Self {
-            Builder::new()
-                .push_opcode(OP_DUP)
-                .push_opcode(OP_HASH160)
-                .push_slice(pubkey_hash)
-                .push_opcode(OP_EQUALVERIFY)
-                .push_opcode(OP_CHECKSIG)
-                .into_script()
-        }
-
-        /// Generates P2SH-type of scriptPubkey with a given hash of the redeem script.
-        fn new_p2sh(script_hash: ScriptHash) -> Self {
-            Builder::new()
-                .push_opcode(OP_HASH160)
-                .push_slice(script_hash)
-                .push_opcode(OP_EQUAL)
-                .into_script()
-        }
-
-        /// Generates P2WPKH-type of scriptPubkey.
-        fn new_p2wpkh(pubkey_hash: WPubkeyHash) -> Self {
-            // pubkey hash is 20 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
-            new_witness_program_unchecked(WitnessVersion::V0, pubkey_hash)
-        }
-
-        /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script.
-        fn new_p2wsh(script_hash: WScriptHash) -> Self {
-            // script hash is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
-            new_witness_program_unchecked(WitnessVersion::V0, script_hash)
-        }
-
-        /// Generates P2TR for script spending path using an internal public key and some optional
-        /// script tree Merkle root.
-        fn new_p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
-            secp: &Secp256k1<C>,
-            internal_key: K,
-            merkle_root: Option<TapNodeHash>,
-        ) -> Self {
-            let internal_key = internal_key.into();
-            let (output_key, _) = internal_key.tap_tweak(secp, merkle_root);
-            // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
-            new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
-        }
-
-        /// Generates P2TR for key spending path for a known [`TweakedPublicKey`].
-        fn new_p2tr_tweaked(output_key: TweakedPublicKey) -> Self {
-            // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
-            new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
-        }
-
-        /// Generates pay to anchor output.
-        fn new_p2a() -> Self {
-            new_witness_program_unchecked(WitnessVersion::V1, P2A_PROGRAM)
-        }
-
-        /// Generates P2WSH-type of scriptPubkey with a given [`WitnessProgram`].
-        fn new_witness_program(witness_program: &WitnessProgram) -> Self {
-            Builder::new()
-                .push_opcode(witness_program.version().into())
-                .push_slice(witness_program.program())
-                .into_script()
-        }
-    }
-}
-
-/// Generates P2WSH-type of scriptPubkey with a given [`WitnessVersion`] and the program bytes.
-/// Does not do any checks on version or program length.
-///
-/// Convenience method used by `new_p2a`, `new_p2wpkh`, `new_p2wsh`, `new_p2tr`, and `new_p2tr_tweaked`.
-pub(super) fn new_witness_program_unchecked<T: AsRef<PushBytes>>(
-    version: WitnessVersion,
-    program: T,
-) -> ScriptBuf {
-    let program = program.as_ref();
-    debug_assert!(program.len() >= 2 && program.len() <= 40);
-    // In SegWit v0, the program must be either 20 bytes (P2WPKH) or 32 bytes (P2WSH) long.
-    debug_assert!(version != WitnessVersion::V0 || program.len() == 20 || program.len() == 32);
-    Builder::new().push_opcode(version.into()).push_slice(program).into_script()
-}
-
-mod sealed {
-    pub trait Sealed {}
-    impl Sealed for super::Script {}
-    impl Sealed for super::ScriptBuf {}
-    impl Sealed for super::Builder {}
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn shortest_witness_program() {
-        let bytes = [0x00; 2]; // Arbitrary bytes, witprog must be between 2 and 40.
-        let version = WitnessVersion::V15; // Arbitrary version number, intentionally not 0 or 1.
-
-        let p = WitnessProgram::new(version, &bytes).expect("failed to create witness program");
-        let script = ScriptBuf::new_witness_program(&p);
-
-        assert_eq!(script.witness_version(), Some(version));
-    }
-
-    #[test]
-    fn longest_witness_program() {
-        let bytes = [0x00; 40]; // Arbitrary bytes, witprog must be between 2 and 40.
-        let version = WitnessVersion::V16; // Arbitrary version number, intentionally not 0 or 1.
-
-        let p = WitnessProgram::new(version, &bytes).expect("failed to create witness program");
-        let script = ScriptBuf::new_witness_program(&p);
-
-        assert_eq!(script.witness_version(), Some(version));
-    }
-}
diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index b62617e5c7..d240d1adec 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -13,13 +13,13 @@
 //!
 //! # Relevant BIPS
 //!
-//! * [BIP 157 - Client Side Block Filtering](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki)
-//! * [BIP 158 - Compact Block Filters for Light Clients](https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki)
+//! * [BIP-0157 - Client Side Block Filtering](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki)
+//! * [BIP-0158 - Compact Block Filters for Light Clients](https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki)
 //!
 //! # Examples
 //!
 //! ```ignore
-//! fn get_script_for_coin(coin: &OutPoint) -> Result<ScriptBuf, BlockFilterError> {
+//! fn get_script_for_coin(coin: &OutPoint) -> Result<ScriptPubKeyBuf, BlockFilterError> {
 //!   // get utxo ...
 //! }
 //!
@@ -31,7 +31,7 @@
 //!
 //! // read and evaluate a filter
 //!
-//! let query: Iterator<Item=ScriptBuf> = // .. some scripts you care about
+//! let query: Iterator<Item=ScriptPubKeyBuf> = // .. some scripts you care about
 //! if filter.match_any(&block_hash, &mut query.map(|s| s.as_bytes())) {
 //!   // get this block
 //! }
@@ -41,36 +41,21 @@ use core::cmp::{self, Ordering};
 use core::convert::Infallible;
 use core::fmt;
 
-use hashes::{sha256d, siphash24, HashEngine as _};
+use hashes::{sha256d, siphash24};
 use internals::array::ArrayExt as _;
 use internals::{write_err, ToU64 as _};
 use io::{BufRead, Write};
 
 use crate::block::{Block, BlockHash, Checked};
 use crate::consensus::{ReadExt, WriteExt};
-use crate::internal_macros::impl_hashencode;
 use crate::prelude::{BTreeSet, Borrow, Vec};
-use crate::script::{Script, ScriptExt as _};
+use crate::script::{ScriptPubKey, ScriptPubKeyExt as _};
 use crate::transaction::OutPoint;
 
-/// Golomb encoding parameter as in BIP-158, see also https://gist.github.com/sipa/576d5f09c3b86c3b1b75598d799fc845
+/// Golomb encoding parameter as in BIP-0158, see also https://gist.github.com/sipa/576d5f09c3b86c3b1b75598d799fc845
 const P: u8 = 19;
 const M: u64 = 784931;
 
-hashes::hash_newtype! {
-    /// Filter hash, as defined in BIP-157.
-    pub struct FilterHash(sha256d::Hash);
-    /// Filter header, as defined in BIP-157.
-    pub struct FilterHeader(sha256d::Hash);
-}
-
-hashes::impl_hex_for_newtype!(FilterHash, FilterHeader);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(FilterHash, FilterHeader);
-
-impl_hashencode!(FilterHash);
-impl_hashencode!(FilterHeader);
-
 /// Errors for blockfilter.
 #[derive(Debug)]
 #[non_exhaustive]
@@ -87,11 +72,9 @@ impl From<Infallible> for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        use Error::*;
-
-        match *self {
-            UtxoMissing(ref coin) => write!(f, "unresolved UTXO {}", coin),
-            Io(ref e) => write_err!(f, "I/O error"; e),
+        match self {
+            Self::UtxoMissing(ref coin) => write!(f, "unresolved UTXO {}", coin),
+            Self::Io(ref e) => write_err!(f, "I/O error"; e),
         }
     }
 }
@@ -99,17 +82,15 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Error::*;
-
-        match *self {
-            UtxoMissing(_) => None,
-            Io(ref e) => Some(e),
+        match self {
+            Self::UtxoMissing(_) => None,
+            Self::Io(ref e) => Some(e),
         }
     }
 }
 
 impl From<io::Error> for Error {
-    fn from(io: io::Error) -> Self { Error::Io(io) }
+    fn from(io: io::Error) -> Self { Self::Io(io) }
 }
 
 /// A block filter, as described by BIP 158.
@@ -119,28 +100,18 @@ pub struct BlockFilter {
     pub content: Vec<u8>,
 }
 
-impl FilterHash {
-    /// Computes the filter header from a filter hash and previous filter header.
-    pub fn filter_header(&self, previous_filter_header: FilterHeader) -> FilterHeader {
-        let mut engine = sha256d::Hash::engine();
-        engine.input(self.as_ref());
-        engine.input(previous_filter_header.as_ref());
-        FilterHeader(sha256d::Hash::from_engine(engine))
-    }
-}
-
 impl BlockFilter {
     /// Constructs a new filter from pre-computed data.
-    pub fn new(content: &[u8]) -> BlockFilter { BlockFilter { content: content.to_vec() } }
+    pub fn new(content: &[u8]) -> Self { Self { content: content.to_vec() } }
 
     /// Computes a SCRIPT_FILTER that contains spent and output scripts.
     pub fn new_script_filter<M, S>(
         block: &Block<Checked>,
         script_for_coin: M,
-    ) -> Result<BlockFilter, Error>
+    ) -> Result<Self, Error>
     where
         M: Fn(&OutPoint) -> Result<S, Error>,
-        S: Borrow<Script>,
+        S: Borrow<ScriptPubKey>,
     {
         let mut out = Vec::new();
         let mut writer = BlockFilterWriter::new(&mut out, block);
@@ -149,21 +120,11 @@ impl BlockFilter {
         writer.add_input_scripts(script_for_coin)?;
         writer.finish()?;
 
-        Ok(BlockFilter { content: out })
-    }
-
-    /// Computes this filter's ID in a chain of filters (see [BIP 157]).
-    ///
-    /// [BIP 157]: <https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#Filter_Headers>
-    pub fn filter_header(&self, previous_filter_header: FilterHeader) -> FilterHeader {
-        FilterHash(sha256d::Hash::hash(&self.content)).filter_header(previous_filter_header)
+        Ok(Self { content: out })
     }
 
     /// Computes the canonical hash for the given filter.
-    pub fn filter_hash(&self) -> FilterHash {
-        let hash = sha256d::Hash::hash(&self.content);
-        FilterHash(hash)
-    }
+    pub fn filter_hash(&self) -> sha256d::Hash { sha256d::Hash::hash(&self.content) }
 
     /// Returns true if any query matches against this [`BlockFilter`].
     pub fn match_any<I>(&self, block_hash: BlockHash, query: I) -> Result<bool, Error>
@@ -194,7 +155,7 @@ pub struct BlockFilterWriter<'a, W> {
 
 impl<'a, W: Write> BlockFilterWriter<'a, W> {
     /// Constructs a new [`BlockFilterWriter`] from `block`.
-    pub fn new(writer: &'a mut W, block: &'a Block<Checked>) -> BlockFilterWriter<'a, W> {
+    pub fn new(writer: &'a mut W, block: &'a Block<Checked>) -> Self {
         let block_hash_as_int = block.block_hash().to_byte_array();
         let k0 = u64::from_le_bytes(*block_hash_as_int.sub_array::<0, 8>());
         let k1 = u64::from_le_bytes(*block_hash_as_int.sub_array::<8, 8>());
@@ -205,7 +166,7 @@ impl<'a, W: Write> BlockFilterWriter<'a, W> {
     /// Adds output scripts of the block to filter (excluding OP_RETURN scripts).
     pub fn add_output_scripts(&mut self) {
         for transaction in self.block.transactions() {
-            for output in &transaction.output {
+            for output in &transaction.outputs {
                 if !output.script_pubkey.is_op_return() {
                     self.add_element(output.script_pubkey.as_bytes());
                 }
@@ -217,14 +178,14 @@ impl<'a, W: Write> BlockFilterWriter<'a, W> {
     pub fn add_input_scripts<M, S>(&mut self, script_for_coin: M) -> Result<(), Error>
     where
         M: Fn(&OutPoint) -> Result<S, Error>,
-        S: Borrow<Script>,
+        S: Borrow<ScriptPubKey>,
     {
         for script in self
             .block
             .transactions()
             .iter()
             .skip(1) // skip coinbase
-            .flat_map(|t| t.input.iter().map(|i| &i.previous_output))
+            .flat_map(|t| t.inputs.iter().map(|i| &i.previous_output))
             .map(script_for_coin)
         {
             match script {
@@ -249,11 +210,11 @@ pub struct BlockFilterReader {
 
 impl BlockFilterReader {
     /// Constructs a new [`BlockFilterReader`] from `block_hash`.
-    pub fn new(block_hash: BlockHash) -> BlockFilterReader {
+    pub fn new(block_hash: BlockHash) -> Self {
         let block_hash_as_int = block_hash.to_byte_array();
         let k0 = u64::from_le_bytes(*block_hash_as_int.sub_array::<0, 8>());
         let k1 = u64::from_le_bytes(*block_hash_as_int.sub_array::<8, 8>());
-        BlockFilterReader { reader: GcsFilterReader::new(k0, k1, M, P) }
+        Self { reader: GcsFilterReader::new(k0, k1, M, P) }
     }
 
     /// Returns true if any query matches against this [`BlockFilterReader`].
@@ -285,8 +246,8 @@ pub struct GcsFilterReader {
 
 impl GcsFilterReader {
     /// Constructs a new [`GcsFilterReader`] with specific seed to siphash.
-    pub fn new(k0: u64, k1: u64, m: u64, p: u8) -> GcsFilterReader {
-        GcsFilterReader { filter: GcsFilter::new(k0, k1, p), m }
+    pub fn new(k0: u64, k1: u64, m: u64, p: u8) -> Self {
+        Self { filter: GcsFilter::new(k0, k1, p), m }
     }
 
     /// Returns true if any query matches against this [`GcsFilterReader`].
@@ -304,7 +265,7 @@ impl GcsFilterReader {
         // sort
         mapped.sort_unstable();
         if mapped.is_empty() {
-            return Ok(true);
+            return Ok(false);
         }
         if n_elements == 0 {
             return Ok(false);
@@ -390,7 +351,7 @@ pub struct GcsFilterWriter<'a, W> {
 
 impl<'a, W: Write> GcsFilterWriter<'a, W> {
     /// Constructs a new [`GcsFilterWriter`] wrapping a generic writer, with specific seed to siphash.
-    pub fn new(writer: &'a mut W, k0: u64, k1: u64, m: u64, p: u8) -> GcsFilterWriter<'a, W> {
+    pub fn new(writer: &'a mut W, k0: u64, k1: u64, m: u64, p: u8) -> Self {
         GcsFilterWriter { filter: GcsFilter::new(k0, k1, p), writer, elements: BTreeSet::new(), m }
     }
 
@@ -437,7 +398,7 @@ struct GcsFilter {
 
 impl GcsFilter {
     /// Constructs a new [`GcsFilter`].
-    fn new(k0: u64, k1: u64, p: u8) -> GcsFilter { GcsFilter { k0, k1, p } }
+    fn new(k0: u64, k1: u64, p: u8) -> Self { Self { k0, k1, p } }
 
     /// Golomb-Rice encodes a number `n` to a bit stream (parameter 2^k).
     fn golomb_rice_encode<W>(
@@ -488,9 +449,7 @@ pub struct BitStreamReader<'a, R: ?Sized> {
 
 impl<'a, R: BufRead + ?Sized> BitStreamReader<'a, R> {
     /// Constructs a new [`BitStreamReader`] that reads bitwise from a given `reader`.
-    pub fn new(reader: &'a mut R) -> BitStreamReader<'a, R> {
-        BitStreamReader { buffer: [0u8], reader, offset: 8 }
-    }
+    pub fn new(reader: &'a mut R) -> Self { BitStreamReader { buffer: [0u8], reader, offset: 8 } }
 
     /// Reads nbit bits, returning the bits in a `u64` starting with the rightmost bit.
     ///
@@ -536,9 +495,7 @@ pub struct BitStreamWriter<'a, W> {
 
 impl<'a, W: Write> BitStreamWriter<'a, W> {
     /// Constructs a new [`BitStreamWriter`] that writes bitwise to a given `writer`.
-    pub fn new(writer: &'a mut W) -> BitStreamWriter<'a, W> {
-        BitStreamWriter { buffer: [0u8], writer, offset: 0 }
-    }
+    pub fn new(writer: &'a mut W) -> Self { BitStreamWriter { buffer: [0u8], writer, offset: 0 } }
 
     /// Writes nbits bits from data.
     pub fn write(&mut self, data: u64, mut nbits: u8) -> Result<usize, io::Error> {
@@ -583,7 +540,7 @@ mod test {
 
     use super::*;
     use crate::consensus::encode::deserialize;
-    use crate::ScriptBuf;
+    use crate::ScriptPubKeyBuf;
 
     #[test]
     fn blockfilters() {
@@ -599,19 +556,15 @@ mod test {
             let block = block.assume_checked(None);
             assert_eq!(block.block_hash(), block_hash);
             let scripts = t.get(3).unwrap().as_array().unwrap();
-            let previous_filter_header =
-                t.get(4).unwrap().as_str().unwrap().parse::<FilterHeader>().unwrap();
             let filter_content = hex(t.get(5).unwrap().as_str().unwrap());
-            let filter_header =
-                t.get(6).unwrap().as_str().unwrap().parse::<FilterHeader>().unwrap();
 
             let mut txmap = HashMap::new();
             let mut si = scripts.iter();
             for tx in block.transactions().iter().skip(1) {
-                for input in tx.input.iter() {
+                for input in tx.inputs.iter() {
                     txmap.insert(
                         input.previous_output,
-                        ScriptBuf::from(hex(si.next().unwrap().as_str().unwrap())),
+                        ScriptPubKeyBuf::from(hex(si.next().unwrap().as_str().unwrap())),
                     );
                 }
             }
@@ -649,8 +602,6 @@ mod test {
                         .unwrap());
                 }
             }
-
-            assert_eq!(filter_header, filter.filter_header(previous_filter_header));
         }
     }
 
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 22ed79d7a0..5d02b1a7e6 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! BIP32 implementation.
+//! BIP-0032 implementation.
 //!
-//! Implementation of BIP32 hierarchical deterministic wallets, as defined
+//! Implementation of BIP-0032 hierarchical deterministic wallets, as defined
 //! at <https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki>.
 
 use core::convert::Infallible;
@@ -13,10 +13,9 @@ use core::{fmt, slice};
 use hashes::{hash160, hash_newtype, sha512, Hash, HashEngine, Hmac, HmacEngine};
 use internals::array::ArrayExt;
 use internals::write_err;
-use secp256k1::Secp256k1;
 
 use crate::crypto::key::{CompressedPublicKey, Keypair, PrivateKey, XOnlyPublicKey};
-use crate::internal_macros::{impl_array_newtype, impl_array_newtype_stringify};
+use crate::internal_macros;
 use crate::network::NetworkKind;
 use crate::prelude::{String, Vec};
 
@@ -40,23 +39,28 @@ pub type ExtendedPrivKey = Xpriv;
 /// A chain code
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ChainCode([u8; 32]);
-impl_array_newtype!(ChainCode, u8, 32);
-impl_array_newtype_stringify!(ChainCode, 32);
+internals::impl_array_newtype!(ChainCode, u8, 32);
+internal_macros::impl_array_newtype_stringify!(ChainCode, 32);
 
 impl ChainCode {
     fn from_hmac(hmac: Hmac<sha512::Hash>) -> Self {
-        ChainCode(*hmac.as_byte_array().split_array::<32, 32>().1)
+        Self(*hmac.as_byte_array().split_array::<32, 32>().1)
     }
+
+    /// Copies the underlying bytes into a new `Vec`.
+    #[inline]
+    #[deprecated(since = "TBD", note = "use to_vec instead")]
+    pub fn to_bytes(self) -> alloc::vec::Vec<u8> { self.to_vec() }
 }
 
 /// A fingerprint
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct Fingerprint([u8; 4]);
-impl_array_newtype!(Fingerprint, u8, 4);
-impl_array_newtype_stringify!(Fingerprint, 4);
+internals::impl_array_newtype!(Fingerprint, u8, 4);
+internal_macros::impl_array_newtype_stringify!(Fingerprint, 4);
 
 hash_newtype! {
-    /// Extended key identifier as defined in BIP-32.
+    /// Extended key identifier as defined in BIP-0032.
     pub struct XKeyIdentifier(hash160::Hash);
 }
 
@@ -82,7 +86,7 @@ pub struct Xpriv {
     pub chain_code: ChainCode,
 }
 #[cfg(feature = "serde")]
-internals::serde_string_impl!(Xpriv, "a BIP-32 extended private key");
+internals::serde_string_impl!(Xpriv, "a BIP-0032 extended private key");
 
 #[cfg(not(feature = "std"))]
 impl fmt::Debug for Xpriv {
@@ -115,7 +119,7 @@ pub struct Xpub {
     pub chain_code: ChainCode,
 }
 #[cfg(feature = "serde")]
-internals::serde_string_impl!(Xpub, "a BIP-32 extended public key");
+internals::serde_string_impl!(Xpub, "a BIP-0032 extended public key");
 
 /// A child number for a derived key
 #[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
@@ -133,16 +137,16 @@ pub enum ChildNumber {
 }
 impl ChildNumber {
     /// Normal child number with index 0.
-    pub const ZERO_NORMAL: Self = ChildNumber::Normal { index: 0 };
+    pub const ZERO_NORMAL: Self = Self::Normal { index: 0 };
 
     /// Normal child number with index 1.
-    pub const ONE_NORMAL: Self = ChildNumber::Normal { index: 1 };
+    pub const ONE_NORMAL: Self = Self::Normal { index: 1 };
 
     /// Hardened child number with index 0.
-    pub const ZERO_HARDENED: Self = ChildNumber::Hardened { index: 0 };
+    pub const ZERO_HARDENED: Self = Self::Hardened { index: 0 };
 
     /// Hardened child number with index 1.
-    pub const ONE_HARDENED: Self = ChildNumber::Hardened { index: 1 };
+    pub const ONE_HARDENED: Self = Self::Hardened { index: 1 };
 
     /// Constructs a new [`Normal`] from an index, returns an error if the index is not within
     /// [0, 2^31 - 1].
@@ -150,7 +154,7 @@ impl ChildNumber {
     /// [`Normal`]: #variant.Normal
     pub fn from_normal_idx(index: u32) -> Result<Self, IndexOutOfRangeError> {
         if index & (1 << 31) == 0 {
-            Ok(ChildNumber::Normal { index })
+            Ok(Self::Normal { index })
         } else {
             Err(IndexOutOfRangeError { index })
         }
@@ -162,7 +166,7 @@ impl ChildNumber {
     /// [`Hardened`]: #variant.Hardened
     pub fn from_hardened_idx(index: u32) -> Result<Self, IndexOutOfRangeError> {
         if index & (1 << 31) == 0 {
-            Ok(ChildNumber::Hardened { index })
+            Ok(Self::Hardened { index })
         } else {
             Err(IndexOutOfRangeError { index })
         }
@@ -178,19 +182,42 @@ impl ChildNumber {
     /// [`Hardened`]: #variant.Hardened
     pub fn is_hardened(&self) -> bool {
         match self {
-            ChildNumber::Hardened { .. } => true,
-            ChildNumber::Normal { .. } => false,
+            Self::Hardened { .. } => true,
+            Self::Normal { .. } => false,
         }
     }
 
     /// Returns the child number that is a single increment from this one.
-    pub fn increment(self) -> Result<ChildNumber, IndexOutOfRangeError> {
+    pub fn increment(self) -> Result<Self, IndexOutOfRangeError> {
         // Bare addition in this function is okay, because we have an invariant that
         // `index` is always within [0, 2^31 - 1]. FIXME this is not actually an
         // invariant because the fields are public.
         match self {
-            ChildNumber::Normal { index: idx } => ChildNumber::from_normal_idx(idx + 1),
-            ChildNumber::Hardened { index: idx } => ChildNumber::from_hardened_idx(idx + 1),
+            Self::Normal { index: idx } => Self::from_normal_idx(idx + 1),
+            Self::Hardened { index: idx } => Self::from_hardened_idx(idx + 1),
+        }
+    }
+
+    /// Formats the child number using the provided formatting function.
+    ///
+    /// For hardened child numbers appends a `'` or `hardened_alt_suffix`
+    /// depending on the formatter.
+    fn format_with<F>(
+        &self,
+        f: &mut fmt::Formatter,
+        format_fn: F,
+        hardened_alt_suffix: &str,
+    ) -> fmt::Result
+    where
+        F: Fn(&u32, &mut fmt::Formatter) -> fmt::Result,
+    {
+        match *self {
+            Self::Hardened { index } => {
+                format_fn(&index, f)?;
+                let alt = f.alternate();
+                f.write_str(if alt { hardened_alt_suffix } else { "'" })
+            }
+            Self::Normal { index } => format_fn(&index, f),
         }
     }
 }
@@ -198,9 +225,9 @@ impl ChildNumber {
 impl From<u32> for ChildNumber {
     fn from(number: u32) -> Self {
         if number & (1 << 31) != 0 {
-            ChildNumber::Hardened { index: number ^ (1 << 31) }
+            Self::Hardened { index: number ^ (1 << 31) }
         } else {
-            ChildNumber::Normal { index: number }
+            Self::Normal { index: number }
         }
     }
 }
@@ -216,14 +243,31 @@ impl From<ChildNumber> for u32 {
 
 impl fmt::Display for ChildNumber {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ChildNumber::Hardened { index } => {
-                fmt::Display::fmt(&index, f)?;
-                let alt = f.alternate();
-                f.write_str(if alt { "h" } else { "'" })
-            }
-            ChildNumber::Normal { index } => fmt::Display::fmt(&index, f),
-        }
+        self.format_with(f, fmt::Display::fmt, "h")
+    }
+}
+
+impl fmt::LowerHex for ChildNumber {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.format_with(f, fmt::LowerHex::fmt, "h")
+    }
+}
+
+impl fmt::UpperHex for ChildNumber {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.format_with(f, fmt::UpperHex::fmt, "H")
+    }
+}
+
+impl fmt::Octal for ChildNumber {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.format_with(f, fmt::Octal::fmt, "h")
+    }
+}
+
+impl fmt::Binary for ChildNumber {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.format_with(f, fmt::Binary::fmt, "h")
     }
 }
 
@@ -231,21 +275,21 @@ impl FromStr for ChildNumber {
     type Err = ParseChildNumberError;
 
     fn from_str(inp: &str) -> Result<Self, Self::Err> {
-        let is_hardened = inp.chars().last().map_or(false, |l| l == '\'' || l == 'h');
+        let is_hardened = inp.chars().last().is_some_and(|l| l == '\'' || l == 'h');
         Ok(if is_hardened {
-            ChildNumber::from_hardened_idx(
+            Self::from_hardened_idx(
                 inp[0..inp.len() - 1].parse().map_err(ParseChildNumberError::ParseInt)?,
             )
             .map_err(ParseChildNumberError::IndexOutOfRange)?
         } else {
-            ChildNumber::from_normal_idx(inp.parse().map_err(ParseChildNumberError::ParseInt)?)
+            Self::from_normal_idx(inp.parse().map_err(ParseChildNumberError::ParseInt)?)
                 .map_err(ParseChildNumberError::IndexOutOfRange)?
         })
     }
 }
 
-impl AsRef<[ChildNumber]> for ChildNumber {
-    fn as_ref(&self) -> &[ChildNumber] { slice::from_ref(self) }
+impl AsRef<[Self]> for ChildNumber {
+    fn as_ref(&self) -> &[Self] { slice::from_ref(self) }
 }
 
 #[cfg(feature = "serde")]
@@ -254,7 +298,7 @@ impl<'de> serde::Deserialize<'de> for ChildNumber {
     where
         D: serde::Deserializer<'de>,
     {
-        u32::deserialize(deserializer).map(ChildNumber::from)
+        u32::deserialize(deserializer).map(Self::from)
     }
 }
 
@@ -275,12 +319,12 @@ pub trait IntoDerivationPath {
     fn into_derivation_path(self) -> Result<DerivationPath, ParseChildNumberError>;
 }
 
-/// A BIP-32 derivation path.
+/// A BIP-0032 derivation path.
 #[derive(Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
 pub struct DerivationPath(Vec<ChildNumber>);
 
 #[cfg(feature = "serde")]
-internals::serde_string_impl!(DerivationPath, "a BIP-32 derivation path");
+internals::serde_string_impl!(DerivationPath, "a BIP-0032 derivation path");
 
 impl<I> Index<I> for DerivationPath
 where
@@ -293,7 +337,7 @@ where
 }
 
 impl Default for DerivationPath {
-    fn default() -> DerivationPath { DerivationPath::master() }
+    fn default() -> Self { Self::master() }
 }
 
 impl<T> IntoDerivationPath for T
@@ -314,7 +358,7 @@ impl IntoDerivationPath for &'_ str {
 }
 
 impl From<Vec<ChildNumber>> for DerivationPath {
-    fn from(numbers: Vec<ChildNumber>) -> Self { DerivationPath(numbers) }
+    fn from(numbers: Vec<ChildNumber>) -> Self { Self(numbers) }
 }
 
 impl From<DerivationPath> for Vec<ChildNumber> {
@@ -322,7 +366,7 @@ impl From<DerivationPath> for Vec<ChildNumber> {
 }
 
 impl<'a> From<&'a [ChildNumber]> for DerivationPath {
-    fn from(numbers: &'a [ChildNumber]) -> Self { DerivationPath(numbers.to_vec()) }
+    fn from(numbers: &'a [ChildNumber]) -> Self { Self(numbers.to_vec()) }
 }
 
 impl core::iter::FromIterator<ChildNumber> for DerivationPath {
@@ -330,7 +374,7 @@ impl core::iter::FromIterator<ChildNumber> for DerivationPath {
     where
         T: IntoIterator<Item = ChildNumber>,
     {
-        DerivationPath(Vec::from_iter(iter))
+        Self(Vec::from_iter(iter))
     }
 }
 
@@ -356,7 +400,7 @@ impl FromStr for DerivationPath {
 
         let parts = path.split('/');
         let ret: Result<Vec<ChildNumber>, _> = parts.map(str::parse).collect();
-        Ok(DerivationPath(ret?))
+        Ok(Self(ret?))
     }
 }
 
@@ -370,8 +414,8 @@ pub struct DerivationPathIterator<'a> {
 }
 
 impl<'a> DerivationPathIterator<'a> {
-    /// Start a new [DerivationPathIterator] at the given child.
-    pub fn start_from(path: &'a DerivationPath, start: ChildNumber) -> DerivationPathIterator<'a> {
+    /// Starts a new [DerivationPathIterator] at the given child.
+    pub fn start_from(path: &'a DerivationPath, start: ChildNumber) -> Self {
         DerivationPathIterator { base: path, next_child: Some(start) }
     }
 }
@@ -394,39 +438,39 @@ impl DerivationPath {
     pub fn is_empty(&self) -> bool { self.0.is_empty() }
 
     /// Returns derivation path for a master key (i.e. empty derivation path)
-    pub fn master() -> DerivationPath { DerivationPath(vec![]) }
+    pub fn master() -> Self { Self(vec![]) }
 
     /// Returns whether derivation path represents master key (i.e. it's length
     /// is empty). True for `m` path.
     pub fn is_master(&self) -> bool { self.0.is_empty() }
 
     /// Constructs a new [DerivationPath] that is a child of this one.
-    pub fn child(&self, cn: ChildNumber) -> DerivationPath {
+    pub fn child(&self, cn: ChildNumber) -> Self {
         let mut path = self.0.clone();
         path.push(cn);
-        DerivationPath(path)
+        Self(path)
     }
 
-    /// Convert into a [DerivationPath] that is a child of this one.
-    pub fn into_child(self, cn: ChildNumber) -> DerivationPath {
+    /// Converts into a [DerivationPath] that is a child of this one.
+    pub fn into_child(self, cn: ChildNumber) -> Self {
         let mut path = self.0;
         path.push(cn);
-        DerivationPath(path)
+        Self(path)
     }
 
-    /// Get an [Iterator] over the children of this [DerivationPath]
+    /// Gets an [Iterator] over the children of this [DerivationPath]
     /// starting with the given [ChildNumber].
-    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator {
+    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, cn)
     }
 
-    /// Get an [Iterator] over the unhardened children of this [DerivationPath].
-    pub fn normal_children(&self) -> DerivationPathIterator {
+    /// Gets an [Iterator] over the unhardened children of this [DerivationPath].
+    pub fn normal_children(&self) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, ChildNumber::Normal { index: 0 })
     }
 
-    /// Get an [Iterator] over the hardened children of this [DerivationPath].
-    pub fn hardened_children(&self) -> DerivationPathIterator {
+    /// Gets an [Iterator] over the hardened children of this [DerivationPath].
+    pub fn hardened_children(&self) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, ChildNumber::Hardened { index: 0 })
     }
 
@@ -445,7 +489,7 @@ impl DerivationPath {
     ///
     /// assert_eq!(deriv_1, deriv_2);
     /// ```
-    pub fn extend<T: AsRef<[ChildNumber]>>(&self, path: T) -> DerivationPath {
+    pub fn extend<T: AsRef<[ChildNumber]>>(&self, path: T) -> Self {
         let mut new_path = self.clone();
         new_path.0.extend_from_slice(path.as_ref());
         new_path
@@ -482,11 +526,19 @@ impl fmt::Display for DerivationPath {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut iter = self.0.iter();
         if let Some(first_element) = iter.next() {
-            write!(f, "{}", first_element)?;
+            if f.alternate() {
+                write!(f, "{:#}", first_element)?;
+            } else {
+                write!(f, "{}", first_element)?;
+            }
         }
         for cn in iter {
             f.write_str("/")?;
-            write!(f, "{}", cn)?;
+            if f.alternate() {
+                write!(f, "{:#}", cn)?;
+            } else {
+                write!(f, "{}", cn)?;
+            }
         }
         Ok(())
     }
@@ -500,7 +552,7 @@ impl fmt::Debug for DerivationPath {
 /// master extended public key and a derivation path from it.
 pub type KeySource = (Fingerprint, DerivationPath);
 
-/// A BIP32 error
+/// A BIP-0032 error
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum ParseError {
@@ -528,20 +580,20 @@ impl From<Infallible> for ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseError::*;
-
-        match *self {
-            Secp256k1(ref e) => write_err!(f, "secp256k1 error"; e),
-            UnknownVersion(ref bytes) => write!(f, "unknown version magic bytes: {:?}", bytes),
-            WrongExtendedKeyLength(ref len) =>
+        match self {
+            Self::Secp256k1(ref e) => write_err!(f, "secp256k1 error"; e),
+            Self::UnknownVersion(ref bytes) =>
+                write!(f, "unknown version magic bytes: {:?}", bytes),
+            Self::WrongExtendedKeyLength(ref len) =>
                 write!(f, "encoded extended key data has wrong length {}", len),
-            Base58(ref e) => write_err!(f, "base58 encoding error"; e),
-            InvalidBase58PayloadLength(ref e) => write_err!(f, "base58 payload"; e),
-            InvalidPrivateKeyPrefix =>
-                f.write_str("invalid private key prefix, byte 45 must be 0 as required by BIP-32"),
-            NonZeroParentFingerprintForMasterKey =>
+            Self::Base58(ref e) => write_err!(f, "base58 encoding error"; e),
+            Self::InvalidBase58PayloadLength(ref e) => write_err!(f, "base58 payload"; e),
+            Self::InvalidPrivateKeyPrefix =>
+                f.write_str("invalid private key prefix, byte 45 must be 0 as required by BIP-0032"),
+            Self::NonZeroParentFingerprintForMasterKey =>
                 f.write_str("non-zero parent fingerprint in master key"),
-            NonZeroChildNumberForMasterKey => f.write_str("non-zero child number in master key"),
+            Self::NonZeroChildNumberForMasterKey =>
+                f.write_str("non-zero child number in master key"),
         }
     }
 }
@@ -549,35 +601,31 @@ impl fmt::Display for ParseError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseError::*;
-
-        match *self {
-            Secp256k1(ref e) => Some(e),
-            Base58(ref e) => Some(e),
-            InvalidBase58PayloadLength(ref e) => Some(e),
-            UnknownVersion(_) | WrongExtendedKeyLength(_) => None,
-            InvalidPrivateKeyPrefix => None,
-            NonZeroParentFingerprintForMasterKey => None,
-            NonZeroChildNumberForMasterKey => None,
+        match self {
+            Self::Secp256k1(ref e) => Some(e),
+            Self::Base58(ref e) => Some(e),
+            Self::InvalidBase58PayloadLength(ref e) => Some(e),
+            Self::UnknownVersion(_) | Self::WrongExtendedKeyLength(_) => None,
+            Self::InvalidPrivateKeyPrefix => None,
+            Self::NonZeroParentFingerprintForMasterKey => None,
+            Self::NonZeroChildNumberForMasterKey => None,
         }
     }
 }
 
 impl From<secp256k1::Error> for ParseError {
-    fn from(e: secp256k1::Error) -> ParseError { ParseError::Secp256k1(e) }
+    fn from(e: secp256k1::Error) -> Self { Self::Secp256k1(e) }
 }
 
 impl From<base58::Error> for ParseError {
-    fn from(err: base58::Error) -> Self { ParseError::Base58(err) }
+    fn from(err: base58::Error) -> Self { Self::Base58(err) }
 }
 
 impl From<InvalidBase58PayloadLengthError> for ParseError {
-    fn from(e: InvalidBase58PayloadLengthError) -> ParseError {
-        Self::InvalidBase58PayloadLength(e)
-    }
+    fn from(e: InvalidBase58PayloadLengthError) -> Self { Self::InvalidBase58PayloadLength(e) }
 }
 
-/// A BIP32 error
+/// A BIP-0032 error
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum DerivationError {
@@ -624,7 +672,7 @@ impl From<Infallible> for IndexOutOfRangeError {
 
 impl fmt::Display for IndexOutOfRangeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "index {} out of range [0, 2^31 - 1] (do you have an hardened child number, rather than an index?)", self.index)
+        write!(f, "index {} out of range [0, 2^31 - 1] (do you have a hardened child number, rather than an index?)", self.index)
     }
 }
 
@@ -662,18 +710,18 @@ impl fmt::Display for ParseChildNumberError {
 
 impl Xpriv {
     /// Constructs a new master key from a seed value
-    pub fn new_master(network: impl Into<NetworkKind>, seed: &[u8]) -> Xpriv {
+    pub fn new_master(network: impl Into<NetworkKind>, seed: &[u8]) -> Self {
         let mut engine = HmacEngine::<sha512::HashEngine>::new(b"Bitcoin seed");
         engine.input(seed);
         let hmac = engine.finalize();
 
-        Xpriv {
+        Self {
             network: network.into(),
             depth: 0,
             parent_fingerprint: Default::default(),
             child_number: ChildNumber::ZERO_NORMAL,
-            private_key: secp256k1::SecretKey::from_byte_array(
-                hmac.as_byte_array().split_array::<32, 32>().0,
+            private_key: secp256k1::SecretKey::from_secret_bytes(
+                *hmac.as_byte_array().split_array::<32, 32>().0,
             )
             .expect("cryptographically unreachable"),
             chain_code: ChainCode::from_hmac(hmac),
@@ -690,56 +738,42 @@ impl Xpriv {
     }
 
     /// Constructs a new extended public key from this extended private key.
-    pub fn to_xpub<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Xpub {
-        Xpub::from_xpriv(secp, &self)
-    }
+    pub fn to_xpub(self) -> Xpub { Xpub::from_xpriv(&self) }
 
-    /// Constructs a new BIP340 keypair for Schnorr signatures and Taproot use matching the internal
+    /// Constructs a new BIP-0340 keypair for Schnorr signatures and Taproot use matching the internal
     /// secret key representation.
-    pub fn to_keypair<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Keypair {
-        Keypair::from_seckey_slice(secp, &self.private_key[..])
-            .expect("BIP32 internal private key representation is broken")
+    pub fn to_keypair(self) -> Keypair {
+        Keypair::from_seckey_byte_array(self.private_key.to_secret_bytes())
+            .expect("BIP-0032 internal private key representation is broken")
     }
 
     /// Derives an extended private key from a path.
     ///
     /// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
     #[deprecated(since = "TBD", note = "use `derive_xpriv()` instead")]
-    pub fn derive_priv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<Xpriv, DerivationError> {
-        self.derive_xpriv(secp, path)
+    pub fn derive_priv<P: AsRef<[ChildNumber]>>(&self, path: P) -> Result<Self, DerivationError> {
+        self.derive_xpriv(path)
     }
 
     /// Derives an extended private key from a path.
     ///
     /// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
-    pub fn derive_xpriv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<Xpriv, DerivationError> {
-        let mut sk: Xpriv = *self;
+    pub fn derive_xpriv<P: AsRef<[ChildNumber]>>(&self, path: P) -> Result<Self, DerivationError> {
+        let mut sk: Self = *self;
         for cnum in path.as_ref() {
-            sk = sk.ckd_priv(secp, *cnum)?;
+            sk = sk.ckd_priv(*cnum)?;
         }
         Ok(sk)
     }
 
     /// Private->Private child key derivation
-    fn ckd_priv<C: secp256k1::Signing>(
-        &self,
-        secp: &Secp256k1<C>,
-        i: ChildNumber,
-    ) -> Result<Xpriv, DerivationError> {
+    fn ckd_priv(&self, i: ChildNumber) -> Result<Self, DerivationError> {
         let mut engine = HmacEngine::<sha512::HashEngine>::new(&self.chain_code[..]);
         match i {
             ChildNumber::Normal { .. } => {
                 // Non-hardened key: compute public data and use that
                 engine.input(
-                    &secp256k1::PublicKey::from_secret_key(secp, &self.private_key).serialize()[..],
+                    &secp256k1::PublicKey::from_secret_key(&self.private_key).serialize()[..],
                 );
             }
             ChildNumber::Hardened { .. } => {
@@ -751,24 +785,25 @@ impl Xpriv {
 
         engine.input(&u32::from(i).to_be_bytes());
         let hmac: Hmac<sha512::Hash> = engine.finalize();
-        let sk =
-            secp256k1::SecretKey::from_byte_array(hmac.as_byte_array().split_array::<32, 32>().0)
-                .expect("statistically impossible to hit");
+        let sk = secp256k1::SecretKey::from_secret_bytes(
+            *hmac.as_byte_array().split_array::<32, 32>().0,
+        )
+        .expect("statistically impossible to hit");
         let tweaked =
             sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit");
 
-        Ok(Xpriv {
+        Ok(Self {
             network: self.network,
             depth: self.depth.checked_add(1).ok_or(DerivationError::MaximumDepthExceeded)?,
-            parent_fingerprint: self.fingerprint(secp),
+            parent_fingerprint: self.fingerprint(),
             child_number: i,
             private_key: tweaked,
             chain_code: ChainCode::from_hmac(hmac),
         })
     }
 
-    /// Decoding extended private key from binary data according to BIP 32
-    pub fn decode(data: &[u8]) -> Result<Xpriv, ParseError> {
+    /// Decoding extended private key from binary data according to BIP-0032
+    pub fn decode(data: &[u8]) -> Result<Self, ParseError> {
         let Common { network, depth, parent_fingerprint, child_number, chain_code, key } =
             Common::decode(data)?;
 
@@ -783,17 +818,17 @@ impl Xpriv {
             return Err(ParseError::InvalidPrivateKeyPrefix);
         }
 
-        Ok(Xpriv {
+        Ok(Self {
             network,
             depth,
             parent_fingerprint,
             child_number,
             chain_code,
-            private_key: secp256k1::SecretKey::from_byte_array(private_key)?,
+            private_key: secp256k1::SecretKey::from_secret_bytes(*private_key)?,
         })
     }
 
-    /// Extended private key binary encoding according to BIP 32
+    /// Extended private key binary encoding according to BIP-0032
     pub fn encode(&self) -> [u8; 78] {
         let mut ret = [0; 78];
         ret[0..4].copy_from_slice(&match self.network {
@@ -810,31 +845,27 @@ impl Xpriv {
     }
 
     /// Returns the HASH160 of the public key belonging to the xpriv
-    pub fn identifier<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> XKeyIdentifier {
-        Xpub::from_xpriv(secp, self).identifier()
-    }
+    pub fn identifier(&self) -> XKeyIdentifier { Xpub::from_xpriv(self).identifier() }
 
     /// Returns the first four bytes of the identifier
-    pub fn fingerprint<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Fingerprint {
-        self.identifier(secp).as_byte_array().sub_array::<0, 4>().into()
+    pub fn fingerprint(&self) -> Fingerprint {
+        self.identifier().as_byte_array().sub_array::<0, 4>().into()
     }
 }
 
 impl Xpub {
     /// Constructs a new extended public key from an extended private key.
     #[deprecated(since = "TBD", note = "use `from_xpriv()` instead")]
-    pub fn from_priv<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &Xpriv) -> Xpub {
-        Self::from_xpriv(secp, sk)
-    }
+    pub fn from_priv(sk: &Xpriv) -> Self { Self::from_xpriv(sk) }
 
     /// Constructs a new extended public key from an extended private key.
-    pub fn from_xpriv<C: secp256k1::Signing>(secp: &Secp256k1<C>, xpriv: &Xpriv) -> Xpub {
-        Xpub {
+    pub fn from_xpriv(xpriv: &Xpriv) -> Self {
+        Self {
             network: xpriv.network,
             depth: xpriv.depth,
             parent_fingerprint: xpriv.parent_fingerprint,
             child_number: xpriv.child_number,
-            public_key: secp256k1::PublicKey::from_secret_key(secp, &xpriv.private_key),
+            public_key: secp256k1::PublicKey::from_secret_key(&xpriv.private_key),
             chain_code: xpriv.chain_code,
         }
     }
@@ -846,12 +877,12 @@ impl Xpub {
     /// Constructs a new ECDSA compressed public key matching internal public key representation.
     pub fn to_public_key(self) -> CompressedPublicKey { CompressedPublicKey(self.public_key) }
 
-    /// Constructs a new BIP340 x-only public key for BIP-340 signatures and Taproot use matching
+    /// Constructs a new BIP-0340 x-only public key for BIP-0340 signatures and Taproot use matching
     /// the internal public key representation.
     #[deprecated(since = "TBD", note = "use `to_x_only_public_key()` instead")]
     pub fn to_x_only_pub(self) -> XOnlyPublicKey { self.to_x_only_public_key() }
 
-    /// Constructs a new BIP340 x-only public key for BIP-340 signatures and Taproot use matching
+    /// Constructs a new BIP-0340 x-only public key for BIP-0340 signatures and Taproot use matching
     /// the internal public key representation.
     pub fn to_x_only_public_key(self) -> XOnlyPublicKey { XOnlyPublicKey::from(self.public_key) }
 
@@ -859,30 +890,22 @@ impl Xpub {
     ///
     /// The `path` argument can be any type implementing `AsRef<ChildNumber>`, such as `DerivationPath`, for instance.
     #[deprecated(since = "TBD", note = "use `derive_xpub()` instead")]
-    pub fn derive_pub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<Xpub, DerivationError> {
-        self.derive_xpub(secp, path)
+    pub fn derive_pub<P: AsRef<[ChildNumber]>>(&self, path: P) -> Result<Self, DerivationError> {
+        self.derive_xpub(path)
     }
 
     /// Attempts to derive an extended public key from a path.
     ///
     /// The `path` argument can be any type implementing `AsRef<ChildNumber>`, such as `DerivationPath`, for instance.
-    pub fn derive_xpub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<Xpub, DerivationError> {
-        let mut pk: Xpub = *self;
+    pub fn derive_xpub<P: AsRef<[ChildNumber]>>(&self, path: P) -> Result<Self, DerivationError> {
+        let mut pk: Self = *self;
         for cnum in path.as_ref() {
-            pk = pk.ckd_pub(secp, *cnum)?
+            pk = pk.ckd_pub(*cnum)?
         }
         Ok(pk)
     }
 
-    /// Compute the scalar tweak added to this key to get a child key
+    /// Computes the scalar tweak added to this key to get a child key
     pub fn ckd_pub_tweak(
         &self,
         i: ChildNumber,
@@ -895,8 +918,8 @@ impl Xpub {
                 engine.input(&n.to_be_bytes());
 
                 let hmac = engine.finalize();
-                let private_key = secp256k1::SecretKey::from_byte_array(
-                    hmac.as_byte_array().split_array::<32, 32>().0,
+                let private_key = secp256k1::SecretKey::from_secret_bytes(
+                    *hmac.as_byte_array().split_array::<32, 32>().0,
                 )
                 .expect("cryptographically unreachable");
                 let chain_code = ChainCode::from_hmac(hmac);
@@ -906,16 +929,12 @@ impl Xpub {
     }
 
     /// Public->Public child key derivation
-    pub fn ckd_pub<C: secp256k1::Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-        i: ChildNumber,
-    ) -> Result<Xpub, DerivationError> {
+    pub fn ckd_pub(&self, i: ChildNumber) -> Result<Self, DerivationError> {
         let (sk, chain_code) = self.ckd_pub_tweak(i)?;
         let tweaked =
-            self.public_key.add_exp_tweak(secp, &sk.into()).expect("cryptographically unreachable");
+            self.public_key.add_exp_tweak(&sk.into()).expect("cryptographically unreachable");
 
-        Ok(Xpub {
+        Ok(Self {
             network: self.network,
             depth: self.depth.checked_add(1).ok_or(DerivationError::MaximumDepthExceeded)?,
             parent_fingerprint: self.fingerprint(),
@@ -925,8 +944,8 @@ impl Xpub {
         })
     }
 
-    /// Decoding extended public key from binary data according to BIP 32
-    pub fn decode(data: &[u8]) -> Result<Xpub, ParseError> {
+    /// Decoding extended public key from binary data according to BIP-0032
+    pub fn decode(data: &[u8]) -> Result<Self, ParseError> {
         let Common { network, depth, parent_fingerprint, child_number, chain_code, key } =
             Common::decode(data)?;
 
@@ -936,7 +955,7 @@ impl Xpub {
             unknown => return Err(ParseError::UnknownVersion(unknown)),
         };
 
-        Ok(Xpub {
+        Ok(Self {
             network,
             depth,
             parent_fingerprint,
@@ -946,7 +965,7 @@ impl Xpub {
         })
     }
 
-    /// Extended public key binary encoding according to BIP 32
+    /// Extended public key binary encoding according to BIP-0032
     pub fn encode(&self) -> [u8; 78] {
         let mut ret = [0; 78];
         ret[0..4].copy_from_slice(&match self.network {
@@ -981,14 +1000,14 @@ impl fmt::Display for Xpriv {
 impl FromStr for Xpriv {
     type Err = ParseError;
 
-    fn from_str(inp: &str) -> Result<Xpriv, ParseError> {
+    fn from_str(inp: &str) -> Result<Self, ParseError> {
         let data = base58::decode_check(inp)?;
 
         if data.len() != 78 {
             return Err(InvalidBase58PayloadLengthError { length: data.len() }.into());
         }
 
-        Xpriv::decode(&data)
+        Self::decode(&data)
     }
 }
 
@@ -1001,23 +1020,23 @@ impl fmt::Display for Xpub {
 impl FromStr for Xpub {
     type Err = ParseError;
 
-    fn from_str(inp: &str) -> Result<Xpub, ParseError> {
+    fn from_str(inp: &str) -> Result<Self, ParseError> {
         let data = base58::decode_check(inp)?;
 
         if data.len() != 78 {
             return Err(InvalidBase58PayloadLengthError { length: data.len() }.into());
         }
 
-        Xpub::decode(&data)
+        Self::decode(&data)
     }
 }
 
 impl From<Xpub> for XKeyIdentifier {
-    fn from(key: Xpub) -> XKeyIdentifier { key.identifier() }
+    fn from(key: Xpub) -> Self { key.identifier() }
 }
 
 impl From<&Xpub> for XKeyIdentifier {
-    fn from(key: &Xpub) -> XKeyIdentifier { key.identifier() }
+    fn from(key: &Xpub) -> Self { key.identifier() }
 }
 
 /// Decoded base58 data was an invalid length.
@@ -1077,7 +1096,7 @@ impl Common {
             }
         }
 
-        Ok(Common {
+        Ok(Self {
             network,
             depth,
             parent_fingerprint: parent_fingerprint.into(),
@@ -1098,70 +1117,137 @@ mod tests {
     use super::*;
 
     #[test]
-    fn parse_derivation_path() {
-        assert!(matches!(
-            "n/0'/0".parse::<DerivationPath>(),
-            Err(ParseChildNumberError::ParseInt(..)),
-        ));
-        assert!(matches!(
-            "4/m/5".parse::<DerivationPath>(),
-            Err(ParseChildNumberError::ParseInt(..)),
-        ));
-        assert!(matches!(
-            "//3/0'".parse::<DerivationPath>(),
-            Err(ParseChildNumberError::ParseInt(..)),
-        ));
-        assert!(matches!(
-            "0h/0x".parse::<DerivationPath>(),
-            Err(ParseChildNumberError::ParseInt(..)),
-        ));
+    fn parse_derivation_path_invalid_format() {
+        let invalid_paths = ["n/0'/0", "4/m/5", "//3/0'", "0h/0x"];
+        for path in &invalid_paths {
+            assert!(matches!(
+                path.parse::<DerivationPath>(),
+                Err(ParseChildNumberError::ParseInt(..)),
+            ));
+        }
+    }
+
+    #[test]
+    fn test_derivation_path_display() {
+        let path = DerivationPath::from_str("m/84'/0'/0'/0/0").unwrap();
+        assert_eq!(format!("{}", path), "84'/0'/0'/0/0");
+        assert_eq!(format!("{:#}", path), "84h/0h/0h/0/0");
+    }
+
+    #[test]
+    fn test_lowerhex_formatting() {
+        let normal = Normal { index: 42 };
+        let hardened = Hardened { index: 42 };
+
+        assert_eq!(format!("{:x}", normal), "2a");
+        assert_eq!(format!("{:#x}", normal), "0x2a");
+
+        assert_eq!(format!("{:x}", hardened), "2a'");
+        assert_eq!(format!("{:#x}", hardened), "0x2ah");
+    }
+
+    #[test]
+    fn test_upperhex_formatting() {
+        let normal = Normal { index: 42 };
+        let hardened = Hardened { index: 42 };
+
+        assert_eq!(format!("{:X}", normal), "2A");
+        assert_eq!(format!("{:#X}", normal), "0x2A");
+
+        assert_eq!(format!("{:X}", hardened), "2A'");
+        assert_eq!(format!("{:#X}", hardened), "0x2AH");
+    }
+
+    #[test]
+    fn test_octal_formatting() {
+        let normal = Normal { index: 42 };
+        let hardened = Hardened { index: 42 };
+
+        assert_eq!(format!("{:o}", normal), "52");
+        assert_eq!(format!("{:#o}", normal), "0o52");
+
+        assert_eq!(format!("{:o}", hardened), "52'");
+        assert_eq!(format!("{:#o}", hardened), "0o52h");
+    }
+
+    #[test]
+    fn test_binary_formatting() {
+        let normal = Normal { index: 42 };
+        let hardened = Hardened { index: 42 };
+
+        assert_eq!(format!("{:b}", normal), "101010");
+        assert_eq!(format!("{:#b}", normal), "0b101010");
+
+        assert_eq!(format!("{:b}", hardened), "101010'");
+        assert_eq!(format!("{:#b}", hardened), "0b101010h");
+    }
+
+    #[test]
+    fn parse_derivation_path_out_of_range() {
+        let invalid_path = "2147483648";
         assert_eq!(
-            "2147483648".parse::<DerivationPath>(),
+            invalid_path.parse::<DerivationPath>(),
             Err(ParseChildNumberError::IndexOutOfRange(IndexOutOfRangeError { index: 2147483648 })),
         );
+    }
 
+    #[test]
+    fn parse_derivation_path_valid_empty_master() {
+        // Sanity checks.
+        assert_eq!(DerivationPath::master(), DerivationPath(vec![]));
         assert_eq!(DerivationPath::master(), "".parse::<DerivationPath>().unwrap());
         assert_eq!(DerivationPath::master(), DerivationPath::default());
 
-        // Acceptable forms for a master path.
+        // Empty is the same as with an `m`.
+        assert_eq!("".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
         assert_eq!("m".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
         assert_eq!("m/".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
-        assert_eq!("".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
+    }
 
-        assert_eq!("0'".parse::<DerivationPath>(), Ok(vec![ChildNumber::ZERO_HARDENED].into()));
-        assert_eq!(
-            "0'/1".parse::<DerivationPath>(),
-            Ok(vec![ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL].into())
-        );
-        assert_eq!(
-            "0h/1/2'".parse::<DerivationPath>(),
-            Ok(vec![
-                ChildNumber::ZERO_HARDENED,
-                ChildNumber::ONE_NORMAL,
-                ChildNumber::from_hardened_idx(2).unwrap(),
-            ]
-            .into())
-        );
-        assert_eq!(
-            "0'/1/2h/2".parse::<DerivationPath>(),
-            Ok(vec![
-                ChildNumber::ZERO_HARDENED,
-                ChildNumber::ONE_NORMAL,
-                ChildNumber::from_hardened_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(2).unwrap(),
-            ]
-            .into())
-        );
-        let want = DerivationPath::from(vec![
-            ChildNumber::ZERO_HARDENED,
-            ChildNumber::ONE_NORMAL,
-            ChildNumber::from_hardened_idx(2).unwrap(),
-            ChildNumber::from_normal_idx(2).unwrap(),
-            ChildNumber::from_normal_idx(1000000000).unwrap(),
-        ]);
-        assert_eq!("0'/1/2'/2/1000000000".parse::<DerivationPath>().unwrap(), want);
-        assert_eq!("m/0'/1/2'/2/1000000000".parse::<DerivationPath>().unwrap(), want);
+    #[test]
+    fn parse_derivation_path_valid() {
+        let valid_paths = [
+            ("0'", vec![ChildNumber::ZERO_HARDENED]),
+            ("0'/1", vec![ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL]),
+            (
+                "0h/1/2'",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                ],
+            ),
+            (
+                "0'/1/2h/2",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(2).unwrap(),
+                ],
+            ),
+            (
+                "0'/1/2'/2/1000000000",
+                vec![
+                    ChildNumber::ZERO_HARDENED,
+                    ChildNumber::ONE_NORMAL,
+                    ChildNumber::from_hardened_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(2).unwrap(),
+                    ChildNumber::from_normal_idx(1000000000).unwrap(),
+                ],
+            ),
+        ];
+        for (path, expected) in valid_paths {
+            // Access the inner private field so we don't have to clone expected.
+            assert_eq!(path.parse::<DerivationPath>().unwrap().0, expected);
+            // Test with the leading `m` for good measure.
+            let prefixed = format!("m/{}", path);
+            assert_eq!(prefixed.parse::<DerivationPath>().unwrap().0, expected);
+        }
+    }
 
+    #[test]
+    fn parse_derivation_path_same_as_into_derivation_path() {
         let s = "0'/50/3'/5/545456";
         assert_eq!(s.parse::<DerivationPath>(), s.into_derivation_path());
         assert_eq!(s.parse::<DerivationPath>(), s.to_string().into_derivation_path());
@@ -1183,8 +1269,7 @@ mod tests {
         assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path);
     }
 
-    fn test_path<C: secp256k1::Signing + secp256k1::Verification>(
-        secp: &Secp256k1<C>,
+    fn test_path(
         network: NetworkKind,
         seed: &[u8],
         path: DerivationPath,
@@ -1192,37 +1277,31 @@ mod tests {
         expected_pk: &str,
     ) {
         let mut sk = Xpriv::new_master(network, seed);
-        let mut pk = Xpub::from_xpriv(secp, &sk);
+        let mut pk = Xpub::from_xpriv(&sk);
 
         // Check derivation convenience method for Xpriv
-        assert_eq!(&sk.derive_xpriv(secp, &path).unwrap().to_string()[..], expected_sk);
+        assert_eq!(&sk.derive_xpriv(&path).unwrap().to_string()[..], expected_sk);
 
         // Check derivation convenience method for Xpub, should error
         // appropriately if any ChildNumber is hardened
         if path.0.iter().any(|cnum| cnum.is_hardened()) {
-            assert_eq!(
-                pk.derive_xpub(secp, &path),
-                Err(DerivationError::CannotDeriveHardenedChild)
-            );
+            assert_eq!(pk.derive_xpub(&path), Err(DerivationError::CannotDeriveHardenedChild));
         } else {
-            assert_eq!(&pk.derive_xpub(secp, &path).unwrap().to_string()[..], expected_pk);
+            assert_eq!(&pk.derive_xpub(&path).unwrap().to_string()[..], expected_pk);
         }
 
         // Derive keys, checking hardened and non-hardened derivation one-by-one
         for &num in path.0.iter() {
-            sk = sk.ckd_priv(secp, num).unwrap();
+            sk = sk.ckd_priv(num).unwrap();
             match num {
                 Normal { .. } => {
-                    let pk2 = pk.ckd_pub(secp, num).unwrap();
-                    pk = Xpub::from_xpriv(secp, &sk);
+                    let pk2 = pk.ckd_pub(num).unwrap();
+                    pk = Xpub::from_xpriv(&sk);
                     assert_eq!(pk, pk2);
                 }
                 Hardened { .. } => {
-                    assert_eq!(
-                        pk.ckd_pub(secp, num),
-                        Err(DerivationError::CannotDeriveHardenedChild)
-                    );
-                    pk = Xpub::from_xpriv(secp, &sk);
+                    assert_eq!(pk.ckd_pub(num), Err(DerivationError::CannotDeriveHardenedChild));
+                    pk = Xpub::from_xpriv(&sk);
                 }
             }
         }
@@ -1282,88 +1361,85 @@ mod tests {
 
     #[test]
     fn vector_1() {
-        let secp = Secp256k1::new();
         let seed = hex!("000102030405060708090a0b0c0d0e0f");
 
         // m
-        test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
                   "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
                   "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
 
         // m/0h
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
                   "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
                   "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
 
         // m/0h/1
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h/1".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h/1".parse().unwrap(),
                    "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
                    "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
 
         // m/0h/1/2h
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h/1/2h".parse().unwrap(),
                   "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
                   "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
 
         // m/0h/1/2h/2
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h/2".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h/1/2h/2".parse().unwrap(),
                   "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
                   "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
 
         // m/0h/1/2h/2/1000000000
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
                   "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
                   "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
     }
 
     #[test]
     fn vector_2() {
-        let secp = Secp256k1::new();
         let seed = hex!("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
 
         // m
-        test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
                   "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
                   "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
 
         // m/0
-        test_path(&secp, NetworkKind::Main, &seed, "m/0".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0".parse().unwrap(),
                   "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
                   "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
 
         // m/0/2147483647h
-        test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0/2147483647h".parse().unwrap(),
                   "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
                   "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
 
         // m/0/2147483647h/1
-        test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1".parse().unwrap(),
                   "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
                   "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
 
         // m/0/2147483647h/1/2147483646h
-        test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
                   "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
                   "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
 
         // m/0/2147483647h/1/2147483646h/2
-        test_path(&secp, NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
                   "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
                   "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
     }
 
     #[test]
     fn vector_3() {
-        let secp = Secp256k1::new();
         let seed = hex!("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be");
 
         // m
-        test_path(&secp, NetworkKind::Main, &seed, "m".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m".parse().unwrap(),
                   "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
                   "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13");
 
         // m/0h
-        test_path(&secp, NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
+        test_path(NetworkKind::Main, &seed, "m/0h".parse().unwrap(),
                   "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
                   "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
     }
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index 7154254d0b..069fdbbaea 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -10,37 +10,48 @@
 use core::convert::Infallible;
 use core::fmt;
 
-use hashes::{sha256d, HashEngine};
 use internals::{compact_size, ToU64};
 use io::{BufRead, Write};
-use units::BlockTime;
 
-use super::Weight;
-use crate::consensus::encode::WriteExt as _;
-use crate::consensus::{encode, Decodable, Encodable};
-use crate::internal_macros::{impl_consensus_encoding, impl_hashencode};
-use crate::merkle_tree::{MerkleNode as _, TxMerkleNode, WitnessMerkleNode};
+use crate::consensus::encode::{self, Decodable, Encodable, WriteExt as _};
+use crate::merkle_tree::{TxMerkleNode, WitnessMerkleNode};
 use crate::network::Params;
-use crate::pow::{Target, Work};
 use crate::prelude::Vec;
-use crate::script::{self, ScriptExt as _};
-use crate::transaction::{Transaction, TransactionExt as _, Wtxid};
+use crate::script::{self, ScriptExt as _, ScriptIntError};
+use crate::transaction::{Coinbase, Transaction, TransactionExt as _};
+use crate::{internal_macros, BlockTime, Target, Weight, Work};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
-pub use primitives::block::{Block, Checked, Unchecked, Validation, Version, BlockHash, Header, WitnessCommitment};
+pub use primitives::block::{
+    Block, Checked, Unchecked, Validation, Version, BlockHash, Header,
+    WitnessCommitment, compute_merkle_root, compute_witness_root, InvalidBlockError,
+};
+#[doc(no_inline)]
+pub use units::block::TooBigForRelativeHeightError;
 #[doc(inline)]
-pub use units::block::{BlockHeight, BlockHeightInterval, TooBigForRelativeHeightError};
+pub use units::block::{BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval};
 
 #[deprecated(since = "TBD", note = "use `BlockHeightInterval` instead")]
 #[doc(hidden)]
 pub type BlockInterval = BlockHeightInterval;
 
-impl_hashencode!(BlockHash);
+impl Encodable for BlockHash {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for BlockHash {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(r)?))
+    }
+}
 
-impl_consensus_encoding!(Header, version, prev_blockhash, merkle_root, time, bits, nonce);
+#[rustfmt::skip]
+internal_macros::impl_consensus_encoding!(Header, version, prev_blockhash, merkle_root, time, bits, nonce);
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Header`] type.
     pub trait HeaderExt impl for Header {
         /// Computes the target (range [0, T] inclusive) that a blockhash must land in to be valid.
@@ -86,7 +97,7 @@ impl Encodable for Version {
 
 impl Decodable for Version {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Decodable::consensus_decode(r).map(Version::from_consensus)
+        Decodable::consensus_decode(r).map(Self::from_consensus)
     }
 }
 
@@ -98,132 +109,7 @@ impl Encodable for BlockTime {
 
 impl Decodable for BlockTime {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Decodable::consensus_decode(r).map(BlockTime::from_u32)
-    }
-}
-
-/// Extension functionality for the [`Block<Unchecked>`] type.
-pub trait BlockUncheckedExt: sealed::Sealed {
-    /// Validates (or checks) a block.
-    ///
-    /// We define valid as:
-    ///
-    /// * The Merkle root of the header matches Merkle root of the transaction list.
-    /// * The witness commitment in coinbase matches the transaction list.
-    fn validate(self) -> Result<Block<Checked>, InvalidBlockError>;
-}
-
-impl BlockUncheckedExt for Block<Unchecked> {
-    fn validate(self) -> Result<Block<Checked>, InvalidBlockError> {
-        let (header, transactions) = self.into_parts();
-
-        if !check_merkle_root(&header, &transactions) {
-            return Err(InvalidBlockError::InvalidMerkleRoot);
-        }
-
-        match check_witness_commitment(&transactions) {
-            (false, _) => Err(InvalidBlockError::InvalidWitnessCommitment),
-            (true, witness_root) => {
-                let block = Block::new_unchecked(header, transactions);
-                Ok(block.assume_checked(witness_root))
-            }
-        }
-    }
-}
-
-/// Computes the Merkle root for a list of transactions.
-pub fn compute_merkle_root(transactions: &[Transaction]) -> Option<TxMerkleNode> {
-    let hashes = transactions.iter().map(|obj| obj.compute_txid());
-    TxMerkleNode::calculate_root(hashes)
-}
-
-/// Computes the witness commitment for a list of transactions.
-pub fn compute_witness_commitment(
-    transactions: &[Transaction],
-    witness_reserved_value: &[u8],
-) -> Option<(WitnessMerkleNode, WitnessCommitment)> {
-    compute_witness_root(transactions).map(|witness_root| {
-        let mut encoder = sha256d::Hash::engine();
-        witness_root.consensus_encode(&mut encoder).expect("engines don't error");
-        encoder.input(witness_reserved_value);
-        let witness_commitment =
-            WitnessCommitment::from_byte_array(sha256d::Hash::from_engine(encoder).to_byte_array());
-        (witness_root, witness_commitment)
-    })
-}
-
-/// Computes the Merkle root of transactions hashed for witness.
-pub fn compute_witness_root(transactions: &[Transaction]) -> Option<WitnessMerkleNode> {
-    let hashes = transactions.iter().enumerate().map(|(i, t)| {
-        if i == 0 {
-            // Replace the first hash with zeroes.
-            Wtxid::COINBASE
-        } else {
-            t.compute_wtxid()
-        }
-    });
-    WitnessMerkleNode::calculate_root(hashes)
-}
-
-/// Checks if Merkle root of header matches Merkle root of the transaction list.
-fn check_merkle_root(header: &Header, transactions: &[Transaction]) -> bool {
-    match compute_merkle_root(transactions) {
-        Some(merkle_root) => header.merkle_root == merkle_root,
-        None => false,
-    }
-}
-
-/// Checks if witness commitment in coinbase matches the transaction list.
-// Returns the Merkle root if it was computed (so it can be cached in `assume_checked`).
-fn check_witness_commitment(transactions: &[Transaction]) -> (bool, Option<WitnessMerkleNode>) {
-    // Witness commitment is optional if there are no transactions using SegWit in the block.
-    if transactions.iter().all(|t| t.input.iter().all(|i| i.witness.is_empty())) {
-        return (true, None);
-    }
-
-    if transactions.is_empty() {
-        return (false, None);
-    }
-
-    if transactions[0].is_coinbase() {
-        let coinbase = transactions[0].clone();
-        if let Some(commitment) = witness_commitment_from_coinbase(&coinbase) {
-            // Witness reserved value is in coinbase input witness.
-            let witness_vec: Vec<_> = coinbase.input[0].witness.iter().collect();
-            if witness_vec.len() == 1 && witness_vec[0].len() == 32 {
-                if let Some((witness_root, witness_commitment)) =
-                    compute_witness_commitment(transactions, witness_vec[0])
-                {
-                    if commitment == witness_commitment {
-                        return (true, Some(witness_root));
-                    }
-                }
-            }
-        }
-    }
-
-    (false, None)
-}
-
-fn witness_commitment_from_coinbase(coinbase: &Transaction) -> Option<WitnessCommitment> {
-    // Consists of OP_RETURN, OP_PUSHBYTES_36, and four "witness header" bytes.
-    const MAGIC: [u8; 6] = [0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
-
-    if !coinbase.is_coinbase() {
-        return None;
-    }
-
-    // Commitment is in the last output that starts with magic bytes.
-    if let Some(pos) = coinbase
-        .output
-        .iter()
-        .rposition(|o| o.script_pubkey.len() >= 38 && o.script_pubkey.as_bytes()[0..6] == MAGIC)
-    {
-        let bytes =
-            <[u8; 32]>::try_from(&coinbase.output[pos].script_pubkey.as_bytes()[6..38]).unwrap();
-        Some(WitnessCommitment::from_byte_array(bytes))
-    } else {
-        None
+        Decodable::consensus_decode(r).map(Self::from_u32)
     }
 }
 
@@ -254,14 +140,21 @@ pub trait BlockCheckedExt: sealed::Sealed {
 
     /// Returns the total block size.
     ///
-    /// > Total size is the block size in bytes with transactions serialized as described in BIP144,
+    /// > Total size is the block size in bytes with transactions serialized as described in BIP-0144,
     /// > including base data and witness data.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
     fn total_size(&self) -> usize;
 
-    /// Returns the coinbase transaction, if one is present.
-    fn coinbase(&self) -> Option<&Transaction>;
+    /// Returns the coinbase transaction.
+    ///
+    /// This method is infallible for checked blocks because validation ensures
+    /// that a valid coinbase transaction is always present.
+    fn coinbase(&self) -> &Coinbase;
 
-    /// Returns the block height, as encoded in the coinbase transaction according to BIP34.
+    /// Returns the block height, as encoded in the coinbase transaction according to BIP-0034.
     fn bip34_block_height(&self) -> Result<u64, Bip34Error>;
 }
 
@@ -269,7 +162,7 @@ impl BlockCheckedExt for Block<Checked> {
     fn new_checked(
         header: Header,
         transactions: Vec<Transaction>,
-    ) -> Result<Block<Checked>, InvalidBlockError> {
+    ) -> Result<Self, InvalidBlockError> {
         let block = Block::new_unchecked(header, transactions);
         block.validate()
     }
@@ -279,7 +172,7 @@ impl BlockCheckedExt for Block<Checked> {
     fn witness_root(&mut self) -> Option<WitnessMerkleNode> { self.cached_witness_root() }
 
     fn weight(&self) -> Weight {
-        // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
+        // This is the exact definition of a weight unit, as defined by BIP-0141 (quote above).
         let wu = block_base_size(self.transactions()) * 3 + self.total_size();
         Weight::from_wu(wu.to_u64())
     }
@@ -293,10 +186,12 @@ impl BlockCheckedExt for Block<Checked> {
         size
     }
 
-    /// Returns the coinbase transaction, if one is present.
-    fn coinbase(&self) -> Option<&Transaction> { self.transactions().first() }
+    fn coinbase(&self) -> &Coinbase {
+        let first_tx = &self.transactions()[0];
+        Coinbase::assume_coinbase_ref(first_tx)
+    }
 
-    /// Returns the block height, as encoded in the coinbase transaction according to BIP34.
+    /// Returns the block height, as encoded in the coinbase transaction according to BIP-0034.
     fn bip34_block_height(&self) -> Result<u64, Bip34Error> {
         // Citing the spec:
         // Add height as the first item in the coinbase transaction's scriptSig,
@@ -311,8 +206,8 @@ impl BlockCheckedExt for Block<Checked> {
             return Err(Bip34Error::Unsupported);
         }
 
-        let cb = self.coinbase().ok_or(Bip34Error::NotPresent)?;
-        let input = cb.input.first().ok_or(Bip34Error::NotPresent)?;
+        let cb = self.coinbase();
+        let input = cb.first_input();
         let push = input
             .script_sig
             .instructions_minimal()
@@ -322,7 +217,7 @@ impl BlockCheckedExt for Block<Checked> {
         match (push.script_num(), push.push_bytes().map(|b| b.read_scriptint())) {
             (Some(num), Some(Ok(_)) | None) =>
                 Ok(num.try_into().map_err(|_| Bip34Error::NegativeHeight)?),
-            (_, Some(Err(err))) => Err(to_bip34_error(err)),
+            (_, Some(Err(err))) => Err(err.into()),
             (None, _) => Err(Bip34Error::NotPresent),
         }
     }
@@ -367,20 +262,20 @@ impl Decodable for Block<Unchecked> {
     #[inline]
     fn consensus_decode_from_finite_reader<R: io::BufRead + ?Sized>(
         r: &mut R,
-    ) -> Result<Block, encode::Error> {
+    ) -> Result<Self, encode::Error> {
         let header = Decodable::consensus_decode_from_finite_reader(r)?;
         let transactions = Decodable::consensus_decode_from_finite_reader(r)?;
 
-        Ok(Block::new_unchecked(header, transactions))
+        Ok(Self::new_unchecked(header, transactions))
     }
 
     #[inline]
-    fn consensus_decode<R: io::BufRead + ?Sized>(r: &mut R) -> Result<Block, encode::Error> {
-        let mut r = r.take(internals::ToU64::to_u64(encode::MAX_VEC_SIZE));
+    fn consensus_decode<R: io::BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let mut r = io::Read::take(r, internals::ToU64::to_u64(encode::MAX_VEC_SIZE));
         let header = Decodable::consensus_decode(&mut r)?;
         let transactions = Decodable::consensus_decode(&mut r)?;
 
-        Ok(Block::new_unchecked(header, transactions))
+        Ok(Self::new_unchecked(header, transactions))
     }
 }
 
@@ -391,45 +286,17 @@ mod sealed {
     impl<V: super::Validation> Sealed for super::Block<V> {}
 }
 
-/// Invalid block error.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum InvalidBlockError {
-    /// Header Merkle root does not match the calculated Merkle root.
-    InvalidMerkleRoot,
-    /// The witness commitment in coinbase transaction does not match the calculated witness_root.
-    InvalidWitnessCommitment,
-}
-
-impl From<Infallible> for InvalidBlockError {
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl fmt::Display for InvalidBlockError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use InvalidBlockError::*;
-
-        match *self {
-            InvalidMerkleRoot => write!(f, "header Merkle root does not match the calculated Merkle root"),
-            InvalidWitnessCommitment => write!(f, "the witness commitment in coinbase transaction does not match the calculated witness_root"),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for InvalidBlockError {}
-
-/// An error when looking up a BIP34 block height.
+/// An error when looking up a BIP-0034 block height.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Bip34Error {
-    /// The block does not support BIP34 yet.
+    /// The block does not support BIP-0034 yet.
     Unsupported,
-    /// No push was present where the BIP34 push was expected.
+    /// No push was present where the BIP-0034 push was expected.
     NotPresent,
-    /// The BIP34 push was not minimally encoded.
+    /// The BIP-0034 push was not minimally encoded.
     NonMinimalPush,
-    /// The BIP34 push was negative.
+    /// The BIP-0034 push was negative.
     NegativeHeight,
 }
 
@@ -439,13 +306,11 @@ impl From<Infallible> for Bip34Error {
 
 impl fmt::Display for Bip34Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Bip34Error::*;
-
-        match *self {
-            Unsupported => write!(f, "block doesn't support BIP34"),
-            NotPresent => write!(f, "BIP34 push not present in block's coinbase"),
-            NonMinimalPush => write!(f, "byte push not minimally encoded"),
-            NegativeHeight => write!(f, "negative BIP34 height"),
+        match self {
+            Self::Unsupported => write!(f, "block doesn't support BIP-0034"),
+            Self::NotPresent => write!(f, "BIP-0034 push not present in block's coinbase"),
+            Self::NonMinimalPush => write!(f, "byte push not minimally encoded"),
+            Self::NegativeHeight => write!(f, "negative BIP-0034 height"),
         }
     }
 }
@@ -453,10 +318,19 @@ impl fmt::Display for Bip34Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Bip34Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Bip34Error::*;
+        match self {
+            Self::Unsupported | Self::NotPresent | Self::NonMinimalPush | Self::NegativeHeight =>
+                None,
+        }
+    }
+}
 
-        match *self {
-            Unsupported | NotPresent | NonMinimalPush | NegativeHeight => None,
+impl From<ScriptIntError> for Bip34Error {
+    #[inline]
+    fn from(err: ScriptIntError) -> Self {
+        match err {
+            ScriptIntError::NonMinimal => Self::NonMinimalPush,
+            _ => Self::NotPresent,
         }
     }
 }
@@ -485,11 +359,9 @@ impl From<Infallible> for ValidationError {
 
 impl fmt::Display for ValidationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ValidationError::*;
-
-        match *self {
-            BadProofOfWork => f.write_str("block target correct but not attained"),
-            BadTarget => f.write_str("block target incorrect"),
+        match self {
+            Self::BadProofOfWork => f.write_str("block target correct but not attained"),
+            Self::BadTarget => f.write_str("block target incorrect"),
         }
     }
 }
@@ -497,10 +369,8 @@ impl fmt::Display for ValidationError {
 #[cfg(feature = "std")]
 impl std::error::Error for ValidationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use self::ValidationError::*;
-
-        match *self {
-            BadProofOfWork | BadTarget => None,
+        match self {
+            Self::BadProofOfWork | Self::BadTarget => None,
         }
     }
 }
@@ -509,20 +379,23 @@ impl std::error::Error for ValidationError {
 mod tests {
     use hex_lit::hex;
     use internals::ToU64 as _;
+    use primitives::Wtxid;
 
     use super::*;
     use crate::consensus::encode::{deserialize, serialize};
     use crate::pow::test_utils::{u128_to_work, u64_to_work};
-    use crate::{block, CompactTarget, Network, TestnetVersion};
+    use crate::script::{ScriptPubKeyBuf, ScriptSigBuf};
+    use crate::transaction::{OutPoint, Transaction, TxIn, TxOut, Txid};
+    use crate::{block, Amount, CompactTarget, Network, Sequence, TestnetVersion, Witness};
 
     #[test]
     fn static_vector() {
         // testnet block 000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b
         let segwit_block = include_bytes!("../../tests/data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw");
         let block: Block = deserialize(&segwit_block[..]).expect("failed to deserialize block");
-        let (header, transactions) = block.into_parts();
+        assert!(block.check_merkle_root());
 
-        assert!(block::check_merkle_root(&header, &transactions));
+        let (header, transactions) = block.into_parts();
         let block = Block::new_unchecked(header, transactions).assume_checked(None);
 
         // Same as `block.check_merkle_root` but do it explicitly.
@@ -539,7 +412,7 @@ mod tests {
         let block = block.assume_checked(None);
 
         let cb_txid = "d574f343976d8e70d91cb278d21044dd8a396019e6db70755a0a50e4783dba38";
-        assert_eq!(block.coinbase().unwrap().compute_txid().to_string(), cb_txid);
+        assert_eq!(block.coinbase().compute_txid().to_string(), cb_txid);
 
         assert_eq!(block.bip34_block_height(), Ok(100_000));
 
@@ -597,12 +470,12 @@ mod tests {
         assert!(decode.is_ok());
         assert!(bad_decode.is_err());
 
-        let (header, transactions) = decode.unwrap().into_parts();
+        let block = decode.unwrap();
         // should be also ok for a non-witness block as commitment is optional in that case
-        let (witness_commitment_matches, witness_root) =
-            block::check_witness_commitment(&transactions);
+        let (witness_commitment_matches, witness_root) = block.check_witness_commitment();
         assert!(witness_commitment_matches);
 
+        let (header, transactions) = block.into_parts();
         let real_decode =
             Block::new_unchecked(header, transactions.clone()).assume_checked(witness_root);
 
@@ -627,10 +500,7 @@ mod tests {
         );
         assert_eq!(real_decode.total_size(), some_block.len());
         assert_eq!(block_base_size(real_decode.transactions()), some_block.len());
-        assert_eq!(
-            real_decode.weight(),
-            Weight::from_non_witness_data_size(some_block.len().to_u64())
-        );
+        assert_eq!(real_decode.weight(), Weight::from_vb_unchecked(some_block.len().to_u64()));
 
         assert_eq!(serialize(&real_decode), some_block);
     }
@@ -649,11 +519,11 @@ mod tests {
 
         assert!(decode.is_ok());
 
-        let (header, transactions) = decode.unwrap().into_parts();
-        let (witness_commitment_matches, witness_root) =
-            block::check_witness_commitment(&transactions);
+        let block = decode.unwrap();
+        let (witness_commitment_matches, witness_root) = block.check_witness_commitment();
         assert!(witness_commitment_matches);
 
+        let (header, transactions) = block.into_parts();
         let real_decode =
             Block::new_unchecked(header, transactions.clone()).assume_checked(witness_root);
 
@@ -761,63 +631,97 @@ mod tests {
         assert!(segwit_signal.is_signalling_soft_fork(1));
         assert!(!segwit_signal.is_signalling_soft_fork(2));
     }
-}
 
-#[cfg(bench)]
-mod benches {
-    use io::sink;
-    use test::{black_box, Bencher};
+    #[test]
+    fn block_validation_success_with_coinbase() {
+        use crate::constants;
+
+        // Use the genesis block which has a valid coinbase
+        let genesis = constants::genesis_block(Network::Bitcoin);
 
-    use super::Block;
-    use crate::consensus::{deserialize, Decodable, Encodable};
+        let header = *genesis.header();
+        let transactions = genesis.transactions().to_vec();
 
-    #[bench]
-    pub fn bench_stream_reader(bh: &mut Bencher) {
-        let big_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
-        assert_eq!(big_block.len(), 1_381_836);
-        let big_block = black_box(big_block);
+        let unchecked_block = Block::new_unchecked(header, transactions);
+        let validated_block = unchecked_block.validate();
 
-        bh.iter(|| {
-            let mut reader = &big_block[..];
-            let block = Block::consensus_decode(&mut reader).unwrap();
-            black_box(&block);
-        });
+        assert!(validated_block.is_ok(), "Genesis block should validate successfully");
     }
 
-    #[bench]
-    pub fn bench_block_serialize(bh: &mut Bencher) {
-        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+    #[test]
+    fn checked_block_coinbase_method() {
+        use crate::constants;
 
-        let block: Block = deserialize(&raw_block[..]).unwrap();
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let coinbase = genesis.coinbase();
 
-        let mut data = Vec::with_capacity(raw_block.len());
+        // Test that coinbase method returns the expected transaction
+        let expected_txid = genesis.transactions()[0].compute_txid();
+        assert_eq!(coinbase.compute_txid(), expected_txid);
+        assert_eq!(coinbase.wtxid(), Wtxid::COINBASE);
 
-        bh.iter(|| {
-            let result = block.consensus_encode(&mut data);
-            black_box(&result);
-            data.clear();
-        });
+        // Test that as_inner() returns the correct transaction
+        assert_eq!(coinbase.as_transaction(), &genesis.transactions()[0]);
     }
 
-    #[bench]
-    pub fn bench_block_serialize_logic(bh: &mut Bencher) {
-        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
-
-        let block: Block = deserialize(&raw_block[..]).unwrap();
+    #[test]
+    fn block_new_checked_validation() {
+        use crate::constants;
+
+        // Test successful validation with genesis block
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let header = *genesis.header();
+        let transactions = genesis.transactions().to_vec();
+
+        let checked_block = Block::new_checked(header, transactions);
+        assert!(checked_block.is_ok(), "Genesis block should validate via new_checked");
+
+        // Test validation failure with empty transactions
+        let empty_result = Block::new_checked(header, Vec::new());
+        match empty_result {
+            Err(InvalidBlockError::NoTransactions) => (),
+            other => panic!("Expected NoTransactions error, got: {:?}", other),
+        }
 
-        bh.iter(|| {
-            let size = block.consensus_encode(&mut sink());
-            black_box(&size);
-        });
+        // Test validation failure with invalid coinbase
+        let non_coinbase_tx = Transaction {
+            version: primitives::transaction::Version::TWO,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![TxIn {
+                previous_output: OutPoint {
+                    txid: Txid::from_byte_array([1; 32]), // Not all zeros
+                    vout: 0,
+                },
+                script_sig: ScriptSigBuf::new(),
+                sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
+                witness: Witness::new(),
+            }],
+            outputs: vec![TxOut { amount: Amount::ONE_BTC, script_pubkey: ScriptPubKeyBuf::new() }],
+        };
+
+        let invalid_coinbase_result = Block::new_checked(header, vec![non_coinbase_tx]);
+        match invalid_coinbase_result {
+            Err(InvalidBlockError::InvalidCoinbase) => (),
+            other => panic!("Expected InvalidCoinbase error, got: {:?}", other),
+        }
     }
 
-    #[bench]
-    pub fn bench_block_deserialize(bh: &mut Bencher) {
-        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+    #[test]
+    fn coinbase_bip34_height_with_coinbase_type() {
+        // testnet block 100,000
+        const BLOCK_HEX: &str = "0200000035ab154183570282ce9afc0b494c9fc6a3cfea05aa8c1add2ecc56490000000038ba3d78e4500a5a7570dbe61960398add4410d278b21cd9708e6d9743f374d544fc055227f1001c29c1ea3b0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3703a08601000427f1001c046a510100522cfabe6d6d0000000000000000000068692066726f6d20706f6f6c7365727665726aac1eeeed88ffffffff0100f2052a010000001976a914912e2b234f941f30b18afbb4fa46171214bf66c888ac00000000";
+        let block: Block = deserialize(&hex!(BLOCK_HEX)).unwrap();
+        let block = block.assume_checked(None);
+
+        // Test that BIP-0034 height extraction works with the Coinbase type
+        assert_eq!(block.bip34_block_height(), Ok(100_000));
 
-        bh.iter(|| {
-            let block: Block = deserialize(&raw_block[..]).unwrap();
-            black_box(&block);
-        });
+        // Test that coinbase method returns a Coinbase type
+        let coinbase = block.coinbase();
+        assert!(coinbase.as_transaction().is_coinbase());
+
+        // Test that the coinbase transaction ID matches expected
+        let cb_txid = "d574f343976d8e70d91cb278d21044dd8a396019e6db70755a0a50e4783dba38";
+        assert_eq!(coinbase.compute_txid().to_string(), cb_txid);
     }
 }
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 6df7336e7d..d44d35aeb2 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -7,7 +7,7 @@
 //! single transaction.
 
 use crate::block::{self, Block, Checked};
-use crate::internal_macros::{impl_array_newtype, impl_array_newtype_stringify};
+use crate::internal_macros::impl_array_newtype_stringify;
 use crate::locktime::absolute;
 use crate::network::{Network, Params};
 use crate::opcodes::all::*;
@@ -79,8 +79,8 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
     let mut ret = Transaction {
         version: transaction::Version::ONE,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![],
-        output: vec![],
+        inputs: vec![],
+        outputs: vec![],
     };
 
     let (in_script, out_script) = {
@@ -105,14 +105,14 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
         }
     };
 
-    ret.input.push(TxIn {
+    ret.inputs.push(TxIn {
         previous_output: OutPoint::COINBASE_PREVOUT,
         script_sig: in_script,
         sequence: Sequence::MAX,
         witness: Witness::default(),
     });
 
-    ret.output.push(TxOut { value: Amount::FIFTY_BTC, script_pubkey: out_script });
+    ret.outputs.push(TxOut { amount: Amount::FIFTY_BTC, script_pubkey: out_script });
 
     // end
     ret
@@ -192,7 +192,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
 /// The uniquely identifying hash of the target blockchain.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ChainHash([u8; 32]);
-impl_array_newtype!(ChainHash, u8, 32);
+internals::impl_array_newtype!(ChainHash, u8, 32);
 impl_array_newtype_stringify!(ChainHash, 32);
 
 impl ChainHash {
@@ -203,7 +203,7 @@ impl ChainHash {
         101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0,
     ]);
     /// `ChainHash` for testnet3 bitcoin.
-    #[deprecated(since = "0.33.0", note = "use `TESTNET3` instead")]
+    #[deprecated(since = "TBD", note = "use `TESTNET3` instead")]
     pub const TESTNET: Self = Self([
         67, 73, 127, 215, 248, 38, 149, 113, 8, 244, 163, 15, 217, 206, 195, 174, 186, 121, 151,
         32, 132, 233, 14, 173, 1, 234, 51, 9, 0, 0, 0, 0,
@@ -259,8 +259,13 @@ impl ChainHash {
 
     /// Converts genesis block hash into `ChainHash`.
     pub fn from_genesis_block_hash(block_hash: crate::BlockHash) -> Self {
-        ChainHash(block_hash.to_byte_array())
+        Self(block_hash.to_byte_array())
     }
+
+    /// Copies the underlying bytes into a new `Vec`.
+    #[inline]
+    #[deprecated(since = "TBD", note = "use to_vec instead")]
+    pub fn to_bytes(self) -> alloc::vec::Vec<u8> { self.to_vec() }
 }
 
 #[cfg(test)]
@@ -277,17 +282,17 @@ mod test {
         let gen = bitcoin_genesis_tx(&Params::MAINNET);
 
         assert_eq!(gen.version, transaction::Version::ONE);
-        assert_eq!(gen.input.len(), 1);
-        assert_eq!(gen.input[0].previous_output.txid, Txid::COINBASE_PREVOUT);
-        assert_eq!(gen.input[0].previous_output.vout, 0xFFFFFFFF);
-        assert_eq!(serialize(&gen.input[0].script_sig),
+        assert_eq!(gen.inputs.len(), 1);
+        assert_eq!(gen.inputs[0].previous_output.txid, Txid::COINBASE_PREVOUT);
+        assert_eq!(gen.inputs[0].previous_output.vout, 0xFFFFFFFF);
+        assert_eq!(serialize(&gen.inputs[0].script_sig),
                    hex!("4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73"));
 
-        assert_eq!(gen.input[0].sequence, Sequence::MAX);
-        assert_eq!(gen.output.len(), 1);
-        assert_eq!(serialize(&gen.output[0].script_pubkey),
+        assert_eq!(gen.inputs[0].sequence, Sequence::MAX);
+        assert_eq!(gen.outputs.len(), 1);
+        assert_eq!(serialize(&gen.outputs[0].script_pubkey),
                    hex!("434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac"));
-        assert_eq!(gen.output[0].value, "50 BTC".parse::<Amount>().unwrap());
+        assert_eq!(gen.outputs[0].amount, "50 BTC".parse::<Amount>().unwrap());
         assert_eq!(gen.lock_time, absolute::LockTime::ZERO);
 
         assert_eq!(
@@ -388,7 +393,7 @@ mod test {
             Network::Testnet(TestnetVersion::V4) => {},
             Network::Signet => {},
             Network::Regtest => {},
-            _ => panic!("update ChainHash::using_genesis_block and chain_hash_genesis_block with new variants"),
+            _ => panic!("update ChainHash::using_genesis_block and chain_hash_and_genesis_block with new variants"),
         }
     }
 
diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index 9d904a1e1e..9758dc2ae3 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -32,16 +32,22 @@ pub mod locktime {
     pub mod absolute {
         //! Provides type [`LockTime`] that implements the logic around nLockTime/OP_CHECKLOCKTIMEVERIFY.
         //!
-        //! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
+        //! There are two types of lock time: lock-by-height and lock-by-time, distinguished by
         //! whether `LockTime < LOCKTIME_THRESHOLD`.
 
         use io::{BufRead, Write};
 
         pub use crate::consensus::encode::{self, Decodable, Encodable};
 
-        /// Re-export everything from the `primitives::locktime::absolute` module.
+        /// Re-export everything from the `units::locktime::absolute` module.
         #[rustfmt::skip]        // Keep public re-exports separate.
-        pub use primitives::locktime::absolute::{ConversionError, Height, LockTime, ParseHeightError, ParseTimeError, MedianTimePast};
+        #[doc(inline)]
+        pub use units::locktime::absolute::{error, Height, LockTime, MedianTimePast};
+        #[doc(no_inline)]
+        pub use units::locktime::absolute::{
+            ConversionError, IncompatibleHeightError, IncompatibleTimeError, ParseHeightError,
+            ParseTimeError,
+        };
 
         #[deprecated(since = "TBD", note = "use `MedianTimePast` instead")]
         #[doc(hidden)]
@@ -58,7 +64,7 @@ pub mod locktime {
         impl Decodable for LockTime {
             #[inline]
             fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-                u32::consensus_decode(r).map(LockTime::from_consensus)
+                u32::consensus_decode(r).map(Self::from_consensus)
             }
         }
     }
@@ -66,13 +72,16 @@ pub mod locktime {
     pub mod relative {
         //! Provides type [`LockTime`] that implements the logic around nSequence/OP_CHECKSEQUENCEVERIFY.
         //!
-        //! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
+        //! There are two types of lock time: lock-by-height and lock-by-time, distinguished by
         //! whether bit 22 of the `u32` consensus value is set.
 
-        /// Re-export everything from the `primitives::locktime::relative` module.
-        pub use primitives::locktime::relative::{
-            DisabledLockTimeError, IncompatibleHeightError, IncompatibleTimeError, LockTime,
-            NumberOf512Seconds, NumberOfBlocks, TimeOverflowError,
+        /// Re-export everything from the `units::locktime::relative` module.
+        #[doc(inline)]
+        pub use units::locktime::relative::{error, LockTime, NumberOf512Seconds, NumberOfBlocks};
+        #[doc(no_inline)]
+        pub use units::locktime::relative::{
+            DisabledLockTimeError, InvalidHeightError, InvalidTimeError, IsSatisfiedByError,
+            IsSatisfiedByHeightError, IsSatisfiedByTimeError, TimeOverflowError,
         };
 
         #[deprecated(since = "TBD", note = "use `NumberOfBlocks` instead")]
diff --git a/bitcoin/src/blockdata/opcodes.rs b/bitcoin/src/blockdata/opcodes.rs
index 5da0295d39..764d37f8f7 100644
--- a/bitcoin/src/blockdata/opcodes.rs
+++ b/bitcoin/src/blockdata/opcodes.rs
@@ -9,9 +9,6 @@
 
 use core::fmt;
 
-#[cfg(feature = "serde")]
-use crate::prelude::ToString;
-
 /// A script Opcode.
 ///
 /// We do not implement Ord on this type because there is no natural ordering on opcodes, but there
@@ -47,26 +44,98 @@ macro_rules! all_opcodes {
                 #[doc = $doc]
                 pub const $op: Opcode = Opcode { code: $val};
             )*
-        }
 
-        /// Push an empty array onto the stack.
-        pub static OP_0: Opcode = OP_PUSHBYTES_0;
-        /// Empty stack is also FALSE.
-        pub static OP_FALSE: Opcode = OP_PUSHBYTES_0;
-        /// Number 1 is also TRUE.
-        pub static OP_TRUE: Opcode = OP_PUSHNUM_1;
-        /// Previously called OP_NOP2.
-        pub static OP_NOP2: Opcode = OP_CLTV;
-        /// Previously called OP_NOP3.
-        pub static OP_NOP3: Opcode = OP_CSV;
+            impl Opcode {
+                /// Returns the string representation of the opcode.
+                ///
+                /// This function maps the `Opcode`'s `code` value (a `u8`) to its corresponding
+                /// Bitcoin Script opcode name.
+                ///
+                /// # Example
+                /// ```
+                /// use bitcoin::opcodes::all::*;
+                ///
+                /// assert_eq!(OP_1.as_str(), "OP_1");
+                /// assert_eq!(OP_1NEGATE.as_str(), "OP_1NEGATE");
+                /// assert_eq!(OP_CHECKMULTISIG.as_str(), "OP_CHECKMULTISIG");
+                /// ```
+                #[inline]
+                pub fn as_str(&self) -> &'static str {
+                    match *self {
+                        $(
+                            $op => stringify!($op),
+                        )+
+                    }
+                }
+            }
+
+            /// Push an empty array onto the stack.
+            pub const OP_0: Opcode = OP_PUSHBYTES_0;
+            /// Empty stack is also FALSE.
+            pub const OP_FALSE: Opcode = OP_PUSHBYTES_0;
+            /// Number 1 is also TRUE.
+            pub const OP_TRUE: Opcode = OP_1;
+            /// Previously called OP_NOP2.
+            pub const OP_NOP2: Opcode = OP_CLTV;
+            /// Previously called OP_NOP3.
+            pub const OP_NOP3: Opcode = OP_CSV;
+
+            /// Push the array `0x81` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_1NEGATE instead")]
+            pub const OP_PUSHNUM_NEG1: Opcode = OP_1NEGATE;
+            /// Push the array `0x01` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_1 instead")]
+            pub const OP_PUSHNUM_1: Opcode = OP_1;
+            /// Push the array `0x02` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_2 instead")]
+            pub const OP_PUSHNUM_2: Opcode = OP_2;
+            /// Push the array `0x03` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_3 instead")]
+            pub const OP_PUSHNUM_3: Opcode = OP_3;
+            /// Push the array `0x04` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_4 instead")]
+            pub const OP_PUSHNUM_4: Opcode = OP_4;
+            /// Push the array `0x05` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_5 instead")]
+            pub const OP_PUSHNUM_5: Opcode = OP_5;
+            /// Push the array `0x06` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_6 instead")]
+            pub const OP_PUSHNUM_6: Opcode = OP_6;
+            /// Push the array `0x07` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_7 instead")]
+            pub const OP_PUSHNUM_7: Opcode = OP_7;
+            /// Push the array `0x08` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_8 instead")]
+            pub const OP_PUSHNUM_8: Opcode = OP_8;
+            /// Push the array `0x09` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_9 instead")]
+            pub const OP_PUSHNUM_9: Opcode = OP_9;
+            /// Push the array `0x0a` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_10 instead")]
+            pub const OP_PUSHNUM_10: Opcode = OP_10;
+            /// Push the array `0x0b` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_11 instead")]
+            pub const OP_PUSHNUM_11: Opcode = OP_11;
+            /// Push the array `0x0c` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_12 instead")]
+            pub const OP_PUSHNUM_12: Opcode = OP_12;
+            /// Push the array `0x0d` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_13 instead")]
+            pub const OP_PUSHNUM_13: Opcode = OP_13;
+            /// Push the array `0x0e` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_14 instead")]
+            pub const OP_PUSHNUM_14: Opcode = OP_14;
+            /// Push the array `0x0f` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_15 instead")]
+            pub const OP_PUSHNUM_15: Opcode = OP_15;
+            /// Push the array `0x10` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_16 instead")]
+            pub const OP_PUSHNUM_16: Opcode = OP_16;
+        }
 
         impl fmt::Display for Opcode {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                 match *self {
-                   $(
-                        $op => core::fmt::Display::fmt(stringify!($op), f),
-                    )+
-                }
+                core::fmt::Display::fmt(self.as_str(), f)
             }
         }
     }
@@ -152,54 +221,54 @@ all_opcodes! {
     OP_PUSHDATA1 => 0x4c, "Read the next byte as N; push the next N bytes as an array onto the stack.";
     OP_PUSHDATA2 => 0x4d, "Read the next 2 bytes as N; push the next N bytes as an array onto the stack.";
     OP_PUSHDATA4 => 0x4e, "Read the next 4 bytes as N; push the next N bytes as an array onto the stack.";
-    OP_PUSHNUM_NEG1 => 0x4f, "Push the array `0x81` onto the stack.";
-    OP_RESERVED => 0x50, "Synonym for OP_RETURN.";
-    OP_PUSHNUM_1 => 0x51, "Push the array `0x01` onto the stack.";
-    OP_PUSHNUM_2 => 0x52, "Push the array `0x02` onto the stack.";
-    OP_PUSHNUM_3 => 0x53, "Push the array `0x03` onto the stack.";
-    OP_PUSHNUM_4 => 0x54, "Push the array `0x04` onto the stack.";
-    OP_PUSHNUM_5 => 0x55, "Push the array `0x05` onto the stack.";
-    OP_PUSHNUM_6 => 0x56, "Push the array `0x06` onto the stack.";
-    OP_PUSHNUM_7 => 0x57, "Push the array `0x07` onto the stack.";
-    OP_PUSHNUM_8 => 0x58, "Push the array `0x08` onto the stack.";
-    OP_PUSHNUM_9 => 0x59, "Push the array `0x09` onto the stack.";
-    OP_PUSHNUM_10 => 0x5a, "Push the array `0x0a` onto the stack.";
-    OP_PUSHNUM_11 => 0x5b, "Push the array `0x0b` onto the stack.";
-    OP_PUSHNUM_12 => 0x5c, "Push the array `0x0c` onto the stack.";
-    OP_PUSHNUM_13 => 0x5d, "Push the array `0x0d` onto the stack.";
-    OP_PUSHNUM_14 => 0x5e, "Push the array `0x0e` onto the stack.";
-    OP_PUSHNUM_15 => 0x5f, "Push the array `0x0f` onto the stack.";
-    OP_PUSHNUM_16 => 0x60, "Push the array `0x10` onto the stack.";
+    OP_1NEGATE => 0x4f, "Push the array `0x81` onto the stack.";
+    OP_RESERVED => 0x50, "Synonym for `OP_RETURN`.";
+    OP_1 => 0x51, "Push the array `0x01` onto the stack.";
+    OP_2 => 0x52, "Push the array `0x02` onto the stack.";
+    OP_3 => 0x53, "Push the array `0x03` onto the stack.";
+    OP_4 => 0x54, "Push the array `0x04` onto the stack.";
+    OP_5 => 0x55, "Push the array `0x05` onto the stack.";
+    OP_6 => 0x56, "Push the array `0x06` onto the stack.";
+    OP_7 => 0x57, "Push the array `0x07` onto the stack.";
+    OP_8 => 0x58, "Push the array `0x08` onto the stack.";
+    OP_9 => 0x59, "Push the array `0x09` onto the stack.";
+    OP_10 => 0x5a, "Push the array `0x0a` onto the stack.";
+    OP_11 => 0x5b, "Push the array `0x0b` onto the stack.";
+    OP_12 => 0x5c, "Push the array `0x0c` onto the stack.";
+    OP_13 => 0x5d, "Push the array `0x0d` onto the stack.";
+    OP_14 => 0x5e, "Push the array `0x0e` onto the stack.";
+    OP_15 => 0x5f, "Push the array `0x0f` onto the stack.";
+    OP_16 => 0x60, "Push the array `0x10` onto the stack.";
     OP_NOP => 0x61, "Does nothing.";
-    OP_VER => 0x62, "Synonym for OP_RETURN.";
+    OP_VER => 0x62, "Synonym for `OP_RETURN`.";
     OP_IF => 0x63, "Pop and execute the next statements if a nonzero element was popped.";
     OP_NOTIF => 0x64, "Pop and execute the next statements if a zero element was popped.";
     OP_VERIF => 0x65, "Fail the script unconditionally, does not even need to be executed.";
     OP_VERNOTIF => 0x66, "Fail the script unconditionally, does not even need to be executed.";
-    OP_ELSE => 0x67, "Execute statements if those after the previous OP_IF were not, and vice-versa. \
-             If there is no previous OP_IF, this acts as a RETURN.";
+    OP_ELSE => 0x67, "Execute statements if those after the previous `OP_IF` were not, and vice-versa. \
+             If there is no previous `OP_IF`, this acts as a RETURN.";
     OP_ENDIF => 0x68, "Pop and execute the next statements if a zero element was popped.";
     OP_VERIFY => 0x69, "If the top value is zero or the stack is empty, fail; otherwise, pop the stack.";
     OP_RETURN => 0x6a, "Fail the script immediately. (Must be executed.).";
     OP_TOALTSTACK => 0x6b, "Pop one element from the main stack onto the alt stack.";
     OP_FROMALTSTACK => 0x6c, "Pop one element from the alt stack onto the main stack.";
     OP_2DROP => 0x6d, "Drops the top two stack items.";
-    OP_2DUP => 0x6e, "Duplicates the top two stack items as AB -> ABAB.";
-    OP_3DUP => 0x6f, "Duplicates the two three stack items as ABC -> ABCABC.";
-    OP_2OVER => 0x70, "Copies the two stack items of items two spaces back to the front, as xxAB -> ABxxAB.";
-    OP_2ROT => 0x71, "Moves the two stack items four spaces back to the front, as xxxxAB -> ABxxxx.";
-    OP_2SWAP => 0x72, "Swaps the top two pairs, as ABCD -> CDAB.";
+    OP_2DUP => 0x6e, "Duplicates the top two stack items as `AB` -> `ABAB`.";
+    OP_3DUP => 0x6f, "Duplicates the top three stack items as `ABC` -> `ABCABC`.";
+    OP_2OVER => 0x70, "Duplicates the third and fourth items from the top of the stack.";
+    OP_2ROT => 0x71, "Moves the two stack items four spaces back to the front, as `xxxxAB` -> `ABxxxx`.";
+    OP_2SWAP => 0x72, "Swaps the top two pairs, as `ABCD` -> `CDAB`.";
     OP_IFDUP => 0x73, "Duplicate the top stack element unless it is zero.";
     OP_DEPTH => 0x74, "Push the current number of stack items onto the stack.";
     OP_DROP => 0x75, "Drops the top stack item.";
     OP_DUP => 0x76, "Duplicates the top stack item.";
     OP_NIP => 0x77, "Drops the second-to-top stack item.";
-    OP_OVER => 0x78, "Copies the second-to-top stack item, as xA -> AxA.";
+    OP_OVER => 0x78, "Copies the second-to-top stack item, as `xA` -> `AxA`.";
     OP_PICK => 0x79, "Pop the top stack element as N. Copy the Nth stack element to the top.";
     OP_ROLL => 0x7a, "Pop the top stack element as N. Move the Nth stack element to the top.";
-    OP_ROT => 0x7b, "Rotate the top three stack items, as [top next1 next2] -> [next2 top next1].";
+    OP_ROT => 0x7b, "Rotate the top three stack items, as `[top next1 next2]` -> `[next2 top next1]`.";
     OP_SWAP => 0x7c, "Swap the top two stack items.";
-    OP_TUCK => 0x7d, "Copy the top stack item to before the second item, as [top next] -> [top next top].";
+    OP_TUCK => 0x7d, "Copy the top stack item to before the second item, as `[top next]` -> `[top next top]`.";
     OP_CAT => 0x7e, "Fail the script unconditionally, does not even need to be executed.";
     OP_SUBSTR => 0x7f, "Fail the script unconditionally, does not even need to be executed.";
     OP_LEFT => 0x80, "Fail the script unconditionally, does not even need to be executed.";
@@ -211,8 +280,8 @@ all_opcodes! {
     OP_XOR => 0x86, "Fail the script unconditionally, does not even need to be executed.";
     OP_EQUAL => 0x87, "Pushes 1 if the inputs are exactly equal, 0 otherwise.";
     OP_EQUALVERIFY => 0x88, "Returns success if the inputs are exactly equal, failure otherwise.";
-    OP_RESERVED1 => 0x89, "Synonym for OP_RETURN.";
-    OP_RESERVED2 => 0x8a, "Synonym for OP_RETURN.";
+    OP_RESERVED1 => 0x89, "Synonym for `OP_RETURN`.";
+    OP_RESERVED2 => 0x8a, "Synonym for `OP_RETURN`.";
     OP_1ADD => 0x8b, "Increment the top stack element in place.";
     OP_1SUB => 0x8c, "Decrement the top stack element in place.";
     OP_2MUL => 0x8d, "Fail the script unconditionally, does not even need to be executed.";
@@ -262,82 +331,82 @@ all_opcodes! {
     OP_NOP9 => 0xb8, "Does nothing.";
     OP_NOP10 => 0xb9, "Does nothing.";
     // Every other opcode acts as OP_RETURN
-    OP_CHECKSIGADD => 0xba, "OP_CHECKSIGADD post tapscript.";
-    OP_RETURN_187 => 0xbb, "Synonym for OP_RETURN.";
-    OP_RETURN_188 => 0xbc, "Synonym for OP_RETURN.";
-    OP_RETURN_189 => 0xbd, "Synonym for OP_RETURN.";
-    OP_RETURN_190 => 0xbe, "Synonym for OP_RETURN.";
-    OP_RETURN_191 => 0xbf, "Synonym for OP_RETURN.";
-    OP_RETURN_192 => 0xc0, "Synonym for OP_RETURN.";
-    OP_RETURN_193 => 0xc1, "Synonym for OP_RETURN.";
-    OP_RETURN_194 => 0xc2, "Synonym for OP_RETURN.";
-    OP_RETURN_195 => 0xc3, "Synonym for OP_RETURN.";
-    OP_RETURN_196 => 0xc4, "Synonym for OP_RETURN.";
-    OP_RETURN_197 => 0xc5, "Synonym for OP_RETURN.";
-    OP_RETURN_198 => 0xc6, "Synonym for OP_RETURN.";
-    OP_RETURN_199 => 0xc7, "Synonym for OP_RETURN.";
-    OP_RETURN_200 => 0xc8, "Synonym for OP_RETURN.";
-    OP_RETURN_201 => 0xc9, "Synonym for OP_RETURN.";
-    OP_RETURN_202 => 0xca, "Synonym for OP_RETURN.";
-    OP_RETURN_203 => 0xcb, "Synonym for OP_RETURN.";
-    OP_RETURN_204 => 0xcc, "Synonym for OP_RETURN.";
-    OP_RETURN_205 => 0xcd, "Synonym for OP_RETURN.";
-    OP_RETURN_206 => 0xce, "Synonym for OP_RETURN.";
-    OP_RETURN_207 => 0xcf, "Synonym for OP_RETURN.";
-    OP_RETURN_208 => 0xd0, "Synonym for OP_RETURN.";
-    OP_RETURN_209 => 0xd1, "Synonym for OP_RETURN.";
-    OP_RETURN_210 => 0xd2, "Synonym for OP_RETURN.";
-    OP_RETURN_211 => 0xd3, "Synonym for OP_RETURN.";
-    OP_RETURN_212 => 0xd4, "Synonym for OP_RETURN.";
-    OP_RETURN_213 => 0xd5, "Synonym for OP_RETURN.";
-    OP_RETURN_214 => 0xd6, "Synonym for OP_RETURN.";
-    OP_RETURN_215 => 0xd7, "Synonym for OP_RETURN.";
-    OP_RETURN_216 => 0xd8, "Synonym for OP_RETURN.";
-    OP_RETURN_217 => 0xd9, "Synonym for OP_RETURN.";
-    OP_RETURN_218 => 0xda, "Synonym for OP_RETURN.";
-    OP_RETURN_219 => 0xdb, "Synonym for OP_RETURN.";
-    OP_RETURN_220 => 0xdc, "Synonym for OP_RETURN.";
-    OP_RETURN_221 => 0xdd, "Synonym for OP_RETURN.";
-    OP_RETURN_222 => 0xde, "Synonym for OP_RETURN.";
-    OP_RETURN_223 => 0xdf, "Synonym for OP_RETURN.";
-    OP_RETURN_224 => 0xe0, "Synonym for OP_RETURN.";
-    OP_RETURN_225 => 0xe1, "Synonym for OP_RETURN.";
-    OP_RETURN_226 => 0xe2, "Synonym for OP_RETURN.";
-    OP_RETURN_227 => 0xe3, "Synonym for OP_RETURN.";
-    OP_RETURN_228 => 0xe4, "Synonym for OP_RETURN.";
-    OP_RETURN_229 => 0xe5, "Synonym for OP_RETURN.";
-    OP_RETURN_230 => 0xe6, "Synonym for OP_RETURN.";
-    OP_RETURN_231 => 0xe7, "Synonym for OP_RETURN.";
-    OP_RETURN_232 => 0xe8, "Synonym for OP_RETURN.";
-    OP_RETURN_233 => 0xe9, "Synonym for OP_RETURN.";
-    OP_RETURN_234 => 0xea, "Synonym for OP_RETURN.";
-    OP_RETURN_235 => 0xeb, "Synonym for OP_RETURN.";
-    OP_RETURN_236 => 0xec, "Synonym for OP_RETURN.";
-    OP_RETURN_237 => 0xed, "Synonym for OP_RETURN.";
-    OP_RETURN_238 => 0xee, "Synonym for OP_RETURN.";
-    OP_RETURN_239 => 0xef, "Synonym for OP_RETURN.";
-    OP_RETURN_240 => 0xf0, "Synonym for OP_RETURN.";
-    OP_RETURN_241 => 0xf1, "Synonym for OP_RETURN.";
-    OP_RETURN_242 => 0xf2, "Synonym for OP_RETURN.";
-    OP_RETURN_243 => 0xf3, "Synonym for OP_RETURN.";
-    OP_RETURN_244 => 0xf4, "Synonym for OP_RETURN.";
-    OP_RETURN_245 => 0xf5, "Synonym for OP_RETURN.";
-    OP_RETURN_246 => 0xf6, "Synonym for OP_RETURN.";
-    OP_RETURN_247 => 0xf7, "Synonym for OP_RETURN.";
-    OP_RETURN_248 => 0xf8, "Synonym for OP_RETURN.";
-    OP_RETURN_249 => 0xf9, "Synonym for OP_RETURN.";
-    OP_RETURN_250 => 0xfa, "Synonym for OP_RETURN.";
-    OP_RETURN_251 => 0xfb, "Synonym for OP_RETURN.";
-    OP_RETURN_252 => 0xfc, "Synonym for OP_RETURN.";
-    OP_RETURN_253 => 0xfd, "Synonym for OP_RETURN.";
-    OP_RETURN_254 => 0xfe, "Synonym for OP_RETURN.";
-    OP_INVALIDOPCODE => 0xff, "Synonym for OP_RETURN."
+    OP_CHECKSIGADD => 0xba, "`OP_CHECKSIGADD` post tapscript.";
+    OP_RETURN_187 => 0xbb, "Synonym for `OP_RETURN`.";
+    OP_RETURN_188 => 0xbc, "Synonym for `OP_RETURN`.";
+    OP_RETURN_189 => 0xbd, "Synonym for `OP_RETURN`.";
+    OP_RETURN_190 => 0xbe, "Synonym for `OP_RETURN`.";
+    OP_RETURN_191 => 0xbf, "Synonym for `OP_RETURN`.";
+    OP_RETURN_192 => 0xc0, "Synonym for `OP_RETURN`.";
+    OP_RETURN_193 => 0xc1, "Synonym for `OP_RETURN`.";
+    OP_RETURN_194 => 0xc2, "Synonym for `OP_RETURN`.";
+    OP_RETURN_195 => 0xc3, "Synonym for `OP_RETURN`.";
+    OP_RETURN_196 => 0xc4, "Synonym for `OP_RETURN`.";
+    OP_RETURN_197 => 0xc5, "Synonym for `OP_RETURN`.";
+    OP_RETURN_198 => 0xc6, "Synonym for `OP_RETURN`.";
+    OP_RETURN_199 => 0xc7, "Synonym for `OP_RETURN`.";
+    OP_RETURN_200 => 0xc8, "Synonym for `OP_RETURN`.";
+    OP_RETURN_201 => 0xc9, "Synonym for `OP_RETURN`.";
+    OP_RETURN_202 => 0xca, "Synonym for `OP_RETURN`.";
+    OP_RETURN_203 => 0xcb, "Synonym for `OP_RETURN`.";
+    OP_RETURN_204 => 0xcc, "Synonym for `OP_RETURN`.";
+    OP_RETURN_205 => 0xcd, "Synonym for `OP_RETURN`.";
+    OP_RETURN_206 => 0xce, "Synonym for `OP_RETURN`.";
+    OP_RETURN_207 => 0xcf, "Synonym for `OP_RETURN`.";
+    OP_RETURN_208 => 0xd0, "Synonym for `OP_RETURN`.";
+    OP_RETURN_209 => 0xd1, "Synonym for `OP_RETURN`.";
+    OP_RETURN_210 => 0xd2, "Synonym for `OP_RETURN`.";
+    OP_RETURN_211 => 0xd3, "Synonym for `OP_RETURN`.";
+    OP_RETURN_212 => 0xd4, "Synonym for `OP_RETURN`.";
+    OP_RETURN_213 => 0xd5, "Synonym for `OP_RETURN`.";
+    OP_RETURN_214 => 0xd6, "Synonym for `OP_RETURN`.";
+    OP_RETURN_215 => 0xd7, "Synonym for `OP_RETURN`.";
+    OP_RETURN_216 => 0xd8, "Synonym for `OP_RETURN`.";
+    OP_RETURN_217 => 0xd9, "Synonym for `OP_RETURN`.";
+    OP_RETURN_218 => 0xda, "Synonym for `OP_RETURN`.";
+    OP_RETURN_219 => 0xdb, "Synonym for `OP_RETURN`.";
+    OP_RETURN_220 => 0xdc, "Synonym for `OP_RETURN`.";
+    OP_RETURN_221 => 0xdd, "Synonym for `OP_RETURN`.";
+    OP_RETURN_222 => 0xde, "Synonym for `OP_RETURN`.";
+    OP_RETURN_223 => 0xdf, "Synonym for `OP_RETURN`.";
+    OP_RETURN_224 => 0xe0, "Synonym for `OP_RETURN`.";
+    OP_RETURN_225 => 0xe1, "Synonym for `OP_RETURN`.";
+    OP_RETURN_226 => 0xe2, "Synonym for `OP_RETURN`.";
+    OP_RETURN_227 => 0xe3, "Synonym for `OP_RETURN`.";
+    OP_RETURN_228 => 0xe4, "Synonym for `OP_RETURN`.";
+    OP_RETURN_229 => 0xe5, "Synonym for `OP_RETURN`.";
+    OP_RETURN_230 => 0xe6, "Synonym for `OP_RETURN`.";
+    OP_RETURN_231 => 0xe7, "Synonym for `OP_RETURN`.";
+    OP_RETURN_232 => 0xe8, "Synonym for `OP_RETURN`.";
+    OP_RETURN_233 => 0xe9, "Synonym for `OP_RETURN`.";
+    OP_RETURN_234 => 0xea, "Synonym for `OP_RETURN`.";
+    OP_RETURN_235 => 0xeb, "Synonym for `OP_RETURN`.";
+    OP_RETURN_236 => 0xec, "Synonym for `OP_RETURN`.";
+    OP_RETURN_237 => 0xed, "Synonym for `OP_RETURN`.";
+    OP_RETURN_238 => 0xee, "Synonym for `OP_RETURN`.";
+    OP_RETURN_239 => 0xef, "Synonym for `OP_RETURN`.";
+    OP_RETURN_240 => 0xf0, "Synonym for `OP_RETURN`.";
+    OP_RETURN_241 => 0xf1, "Synonym for `OP_RETURN`.";
+    OP_RETURN_242 => 0xf2, "Synonym for `OP_RETURN`.";
+    OP_RETURN_243 => 0xf3, "Synonym for `OP_RETURN`.";
+    OP_RETURN_244 => 0xf4, "Synonym for `OP_RETURN`.";
+    OP_RETURN_245 => 0xf5, "Synonym for `OP_RETURN`.";
+    OP_RETURN_246 => 0xf6, "Synonym for `OP_RETURN`.";
+    OP_RETURN_247 => 0xf7, "Synonym for `OP_RETURN`.";
+    OP_RETURN_248 => 0xf8, "Synonym for `OP_RETURN`.";
+    OP_RETURN_249 => 0xf9, "Synonym for `OP_RETURN`.";
+    OP_RETURN_250 => 0xfa, "Synonym for `OP_RETURN`.";
+    OP_RETURN_251 => 0xfb, "Synonym for `OP_RETURN`.";
+    OP_RETURN_252 => 0xfc, "Synonym for `OP_RETURN`.";
+    OP_RETURN_253 => 0xfd, "Synonym for `OP_RETURN`.";
+    OP_RETURN_254 => 0xfe, "Synonym for `OP_RETURN`.";
+    OP_INVALIDOPCODE => 0xff, "Synonym for `OP_RETURN`."
 }
 
 /// Classification context for the opcode.
 ///
 /// Some opcodes like [`OP_RESERVED`] abort the script in `ClassifyContext::Legacy` context,
-/// but will act as `OP_SUCCESSx` in `ClassifyContext::TapScript` (see BIP342 for full list).
+/// but will act as `OP_SUCCESSx` in `ClassifyContext::TapScript` (see BIP-0342 for full list).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum ClassifyContext {
     /// Opcode used in tapscript context.
@@ -397,11 +466,11 @@ impl Opcode {
             | (OP_CHECKMULTISIGVERIFY, ClassifyContext::TapScript) => Class::ReturnOp,
 
             // 1 opcode of PushNum class
-            (OP_PUSHNUM_NEG1, _) => Class::PushNum(-1),
+            (OP_1NEGATE, _) => Class::PushNum(-1),
 
             // 16 opcodes of PushNum class
-            (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
-                Class::PushNum(1 + self.code as i32 - OP_PUSHNUM_1.code as i32),
+            (op, _) if op.code >= OP_1.code && op.code <= OP_16.code =>
+                Class::PushNum(1 + self.code as i32 - OP_1.code as i32),
 
             // 76 opcodes of PushBytes class
             (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(self.code as u32),
@@ -415,7 +484,7 @@ impl Opcode {
     #[inline]
     pub const fn to_u8(self) -> u8 { self.code }
 
-    /// Encodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
+    /// Decodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
     ///
     /// Does not convert `OP_FALSE` to 0. Only `1` to `OP_PUSHNUM_16` are covered.
     ///
@@ -425,8 +494,8 @@ impl Opcode {
     #[inline]
     #[must_use]
     pub const fn decode_pushnum(self) -> Option<u8> {
-        const START: u8 = OP_PUSHNUM_1.code;
-        const END: u8 = OP_PUSHNUM_16.code;
+        const START: u8 = OP_1.code;
+        const END: u8 = OP_16.code;
         match self.code {
             START..=END => Some(self.code - START + 1),
             _ => None,
@@ -436,7 +505,7 @@ impl Opcode {
 
 impl From<u8> for Opcode {
     #[inline]
-    fn from(b: u8) -> Opcode { Opcode { code: b } }
+    fn from(b: u8) -> Self { Self { code: b } }
 }
 
 impl fmt::Debug for Opcode {
@@ -449,7 +518,7 @@ impl serde::Serialize for Opcode {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.serialize_str(self.as_str())
     }
 }
 
@@ -575,11 +644,11 @@ mod tests {
     fn decode_pushnum() {
         // Test all possible opcodes
         // - Sanity check
-        assert_eq!(OP_PUSHNUM_1.code, 0x51_u8);
-        assert_eq!(OP_PUSHNUM_16.code, 0x60_u8);
+        assert_eq!(OP_1.code, 0x51_u8);
+        assert_eq!(OP_16.code, 0x60_u8);
         for i in 0x00..=0xff_u8 {
             let expected = match i {
-                // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
+                // OP_1 ..= OP_16
                 0x51..=0x60 => Some(i - 0x50),
                 _ => None,
             };
@@ -589,22 +658,22 @@ mod tests {
         // Test the named opcode constants
         // - This is the OP right before PUSHNUMs start
         assert!(OP_RESERVED.decode_pushnum().is_none());
-        assert_eq!(OP_PUSHNUM_1.decode_pushnum().expect("pushnum"), 1);
-        assert_eq!(OP_PUSHNUM_2.decode_pushnum().expect("pushnum"), 2);
-        assert_eq!(OP_PUSHNUM_3.decode_pushnum().expect("pushnum"), 3);
-        assert_eq!(OP_PUSHNUM_4.decode_pushnum().expect("pushnum"), 4);
-        assert_eq!(OP_PUSHNUM_5.decode_pushnum().expect("pushnum"), 5);
-        assert_eq!(OP_PUSHNUM_6.decode_pushnum().expect("pushnum"), 6);
-        assert_eq!(OP_PUSHNUM_7.decode_pushnum().expect("pushnum"), 7);
-        assert_eq!(OP_PUSHNUM_8.decode_pushnum().expect("pushnum"), 8);
-        assert_eq!(OP_PUSHNUM_9.decode_pushnum().expect("pushnum"), 9);
-        assert_eq!(OP_PUSHNUM_10.decode_pushnum().expect("pushnum"), 10);
-        assert_eq!(OP_PUSHNUM_11.decode_pushnum().expect("pushnum"), 11);
-        assert_eq!(OP_PUSHNUM_12.decode_pushnum().expect("pushnum"), 12);
-        assert_eq!(OP_PUSHNUM_13.decode_pushnum().expect("pushnum"), 13);
-        assert_eq!(OP_PUSHNUM_14.decode_pushnum().expect("pushnum"), 14);
-        assert_eq!(OP_PUSHNUM_15.decode_pushnum().expect("pushnum"), 15);
-        assert_eq!(OP_PUSHNUM_16.decode_pushnum().expect("pushnum"), 16);
+        assert_eq!(OP_1.decode_pushnum().expect("pushnum"), 1);
+        assert_eq!(OP_2.decode_pushnum().expect("pushnum"), 2);
+        assert_eq!(OP_3.decode_pushnum().expect("pushnum"), 3);
+        assert_eq!(OP_4.decode_pushnum().expect("pushnum"), 4);
+        assert_eq!(OP_5.decode_pushnum().expect("pushnum"), 5);
+        assert_eq!(OP_6.decode_pushnum().expect("pushnum"), 6);
+        assert_eq!(OP_7.decode_pushnum().expect("pushnum"), 7);
+        assert_eq!(OP_8.decode_pushnum().expect("pushnum"), 8);
+        assert_eq!(OP_9.decode_pushnum().expect("pushnum"), 9);
+        assert_eq!(OP_10.decode_pushnum().expect("pushnum"), 10);
+        assert_eq!(OP_11.decode_pushnum().expect("pushnum"), 11);
+        assert_eq!(OP_12.decode_pushnum().expect("pushnum"), 12);
+        assert_eq!(OP_13.decode_pushnum().expect("pushnum"), 13);
+        assert_eq!(OP_14.decode_pushnum().expect("pushnum"), 14);
+        assert_eq!(OP_15.decode_pushnum().expect("pushnum"), 15);
+        assert_eq!(OP_16.decode_pushnum().expect("pushnum"), 16);
         // - This is the OP right after PUSHNUMs end
         assert!(OP_NOP.decode_pushnum().is_none());
     }
@@ -719,24 +788,24 @@ mod tests {
         roundtrip!(unique, OP_PUSHDATA1);
         roundtrip!(unique, OP_PUSHDATA2);
         roundtrip!(unique, OP_PUSHDATA4);
-        roundtrip!(unique, OP_PUSHNUM_NEG1);
+        roundtrip!(unique, OP_1NEGATE);
         roundtrip!(unique, OP_RESERVED);
-        roundtrip!(unique, OP_PUSHNUM_1);
-        roundtrip!(unique, OP_PUSHNUM_2);
-        roundtrip!(unique, OP_PUSHNUM_3);
-        roundtrip!(unique, OP_PUSHNUM_4);
-        roundtrip!(unique, OP_PUSHNUM_5);
-        roundtrip!(unique, OP_PUSHNUM_6);
-        roundtrip!(unique, OP_PUSHNUM_7);
-        roundtrip!(unique, OP_PUSHNUM_8);
-        roundtrip!(unique, OP_PUSHNUM_9);
-        roundtrip!(unique, OP_PUSHNUM_10);
-        roundtrip!(unique, OP_PUSHNUM_11);
-        roundtrip!(unique, OP_PUSHNUM_12);
-        roundtrip!(unique, OP_PUSHNUM_13);
-        roundtrip!(unique, OP_PUSHNUM_14);
-        roundtrip!(unique, OP_PUSHNUM_15);
-        roundtrip!(unique, OP_PUSHNUM_16);
+        roundtrip!(unique, OP_1);
+        roundtrip!(unique, OP_2);
+        roundtrip!(unique, OP_3);
+        roundtrip!(unique, OP_4);
+        roundtrip!(unique, OP_5);
+        roundtrip!(unique, OP_6);
+        roundtrip!(unique, OP_7);
+        roundtrip!(unique, OP_8);
+        roundtrip!(unique, OP_9);
+        roundtrip!(unique, OP_10);
+        roundtrip!(unique, OP_11);
+        roundtrip!(unique, OP_12);
+        roundtrip!(unique, OP_13);
+        roundtrip!(unique, OP_14);
+        roundtrip!(unique, OP_15);
+        roundtrip!(unique, OP_16);
         roundtrip!(unique, OP_NOP);
         roundtrip!(unique, OP_VER);
         roundtrip!(unique, OP_IF);
diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index 7cc5fca7d5..79cbf3c458 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -3,51 +3,197 @@
 use core::fmt;
 
 use hex::DisplayHex as _;
+use internals::array::ArrayExt; // For `split_first`.
 use internals::ToU64 as _;
 
 use super::witness_version::WitnessVersion;
 use super::{
-    Builder, Instruction, InstructionIndices, Instructions, PushBytes, RedeemScriptSizeError,
-    ScriptHash, WScriptHash, WitnessScriptSizeError,
+    Builder, Instruction, InstructionIndices, Instructions, PushBytes, RedeemScript,
+    RedeemScriptSizeError, Script, ScriptHash, ScriptHashableTag, ScriptPubKey, ScriptSig,
+    TapScript, WScriptHash, WitnessScript, WitnessScriptSizeError,
 };
 use crate::consensus::{self, Encodable};
+use crate::key::{PublicKey, UntweakedPublicKey, WPubkeyHash};
 use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
 use crate::policy::{DUST_RELAY_TX_FEE, MAX_OP_RETURN_RELAY};
 use crate::prelude::{sink, String, ToString};
-use crate::taproot::{LeafVersion, TapLeafHash};
-use crate::{Amount, FeeRate};
+use crate::script::{self, ScriptPubKeyBufExt as _};
+use crate::taproot::{LeafVersion, TapLeafHash, TapNodeHash};
+use crate::witness_program::P2A_PROGRAM;
+use crate::{internal_macros, Amount, FeeRate, ScriptPubKeyBuf, WitnessScriptBuf};
 
-#[rustfmt::skip]            // Keep public re-exports separate.
-#[doc(inline)]
-pub use primitives::script::Script;
-
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Script`] type.
-    pub trait ScriptExt impl for Script {
+    pub trait ScriptExt<T> impl<T> for Script<T> {
+        /// Constructs a new script builder
+        fn builder() -> Builder<T> { Builder::new() }
+
+        /// Counts the sigops for this Script using accurate counting.
+        ///
+        /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
+        /// This method uses "accurate" counting. This means that OP_CHECKMULTISIG and its
+        /// verify variant count for N sigops where N is the number of pubkeys used in the
+        /// multisig. However, it will count for 20 sigops if CHECKMULTISIG is not preceded by an
+        /// OP_PUSHNUM from 1 - 16 (this would be an invalid script)
+        ///
+        /// Bitcoin Core uses accurate counting for sigops contained within redeemScripts (P2SH)
+        /// and witnessScripts (P2WSH) only. It uses legacy for sigops in scriptSigs and scriptPubkeys.
+        ///
+        /// (Note: Taproot scripts don't count toward the sigop count of the block,
+        /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
+        /// so do not use this to try and estimate if a Taproot script goes over the sigop budget.)
+        fn count_sigops(&self) -> usize { self.count_sigops_internal(true) }
+
+        /// Counts the sigops for this Script using legacy counting.
+        ///
+        /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
+        /// This method uses "legacy" counting. This means that OP_CHECKMULTISIG and its
+        /// verify variant count for 20 sigops.
+        ///
+        /// Bitcoin Core uses legacy counting for sigops contained within scriptSigs and
+        /// scriptPubkeys. It uses accurate for redeemScripts (P2SH) and witnessScripts (P2WSH).
+        ///
+        /// (Note: Taproot scripts don't count toward the sigop count of the block,
+        /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
+        /// so do not use this to try and estimate if a Taproot script goes over the sigop budget.)
+        fn count_sigops_legacy(&self) -> usize { self.count_sigops_internal(false) }
+
+        /// Checks whether a script is push only.
+        ///
+        /// Note: `OP_RESERVED` (`0x50`) and all the OP_PUSHNUM operations
+        /// are considered push operations.
+        #[inline]
+        fn is_push_only(&self) -> bool {
+            for inst in self.instructions() {
+                match inst {
+                    Err(_) => return false,
+                    Ok(Instruction::PushBytes(_)) => {}
+                    Ok(Instruction::Op(op)) if op.to_u8() <= 0x60 => {}
+                    // From Bitcoin Core
+                    // if (opcode > OP_PUSHNUM_16 (0x60)) return false
+                    Ok(Instruction::Op(_)) => return false,
+                }
+            }
+            true
+        }
+
         /// Returns an iterator over script bytes.
         #[inline]
         fn bytes(&self) -> Bytes<'_> { Bytes(self.as_bytes().iter().copied()) }
 
-        /// Constructs a new script builder
-        fn builder() -> Builder { Builder::new() }
+        /// Iterates over the script instructions.
+        ///
+        /// Each returned item is a nested enum covering opcodes, datapushes and errors.
+        /// At most one error will be returned and then the iterator will end. To instead iterate over
+        /// the script as sequence of bytes call the [`bytes`](Self::bytes) method.
+        ///
+        /// To force minimal pushes, use [`instructions_minimal`](Self::instructions_minimal).
+        #[inline]
+        fn instructions(&self) -> Instructions<'_> {
+            Instructions { data: self.as_bytes().iter(), enforce_minimal: false }
+        }
 
-        /// Returns 160-bit hash of the script for P2SH outputs.
+        /// Iterates over the script instructions while enforcing minimal pushes.
+        ///
+        /// This is similar to [`instructions`](Self::instructions) but an error is returned if a push
+        /// is not minimal.
         #[inline]
-        fn script_hash(&self) -> Result<ScriptHash, RedeemScriptSizeError> {
-            ScriptHash::from_script(self)
+        fn instructions_minimal(&self) -> Instructions<'_> {
+            Instructions { data: self.as_bytes().iter(), enforce_minimal: true }
         }
 
-        /// Returns 256-bit hash of the script for P2WSH outputs.
+        /// Iterates over the script instructions and their indices.
+        ///
+        /// Unless the script contains an error, the returned item consists of an index pointing to the
+        /// position in the script where the instruction begins and the decoded instruction - either an
+        /// opcode or data push.
+        ///
+        /// To force minimal pushes, use [`Self::instruction_indices_minimal`].
         #[inline]
-        fn wscript_hash(&self) -> Result<WScriptHash, WitnessScriptSizeError> {
-            WScriptHash::from_script(self)
+        fn instruction_indices(&self) -> InstructionIndices<'_> {
+            InstructionIndices::from_instructions(self.instructions())
         }
 
-        /// Computes leaf hash of tapscript.
+        /// Iterates over the script instructions and their indices while enforcing minimal pushes.
+        ///
+        /// This is similar to [`instruction_indices`](Self::instruction_indices) but an error is
+        /// returned if a push is not minimal.
         #[inline]
-        fn tapscript_leaf_hash(&self) -> TapLeafHash {
-            TapLeafHash::from_script(self, LeafVersion::TapScript)
+        fn instruction_indices_minimal(&self) -> InstructionIndices<'_> {
+            InstructionIndices::from_instructions(self.instructions_minimal())
+        }
+
+        /// Writes the human-readable assembly representation of the script to the formatter.
+        #[deprecated(since = "TBD", note = "use the script's `Display` impl instead")]
+        fn fmt_asm(&self, f: &mut dyn fmt::Write) -> fmt::Result {
+            write!(f, "{}", self)
+        }
+
+        /// Returns the human-readable assembly representation of the script.
+        #[deprecated(since = "TBD", note = "use `to_string()` instead")]
+        fn to_asm_string(&self) -> String { self.to_string() }
+
+        /// Consensus encodes the script as lower-case hex.
+        #[deprecated(since = "TBD", note = "use `to_hex_string_no_length_prefix` instead")]
+        fn to_hex_string(&self) -> String { self.to_hex_string_no_length_prefix() }
+
+        /// Consensus encodes the script as lower-case hex.
+        ///
+        /// Consensus encoding includes a length prefix. To hex encode without the length prefix use
+        /// `to_hex_string_no_length_prefix`.
+        fn to_hex_string_prefixed(&self) -> String { consensus::encode::serialize_hex(self) }
+
+        /// Encodes the script as lower-case hex.
+        ///
+        /// This is **not** consensus encoding. The returned hex string will not include the length
+        /// prefix. See `to_hex_string_prefixed`.
+        fn to_hex_string_no_length_prefix(&self) -> String {
+            self.as_bytes().to_lower_hex_string()
+        }
+
+        /// Returns the first opcode of the script (if there is any).
+        fn first_opcode(&self) -> Option<Opcode> {
+            self.as_bytes().first().copied().map(From::from)
+        }
+
+        // These methods only exist for scriptPubKey and redeemScript, as indicated by the
+        // where clauses on them.
+
+        /// Returns 160-bit hash of the script for P2SH outputs.
+        #[inline]
+        fn script_hash(&self) -> Result<ScriptHash, RedeemScriptSizeError>
+        where T: ScriptHashableTag
+        {
+            ScriptHash::from_script(self)
+        }
+
+        /// Computes the P2SH output corresponding to this redeem script.
+        fn to_p2sh(&self) -> Result<ScriptPubKeyBuf, RedeemScriptSizeError>
+        where T: ScriptHashableTag
+        {
+            self.script_hash().map(ScriptPubKeyBuf::new_p2sh)
+        }
+
+        /// Returns the script code used for spending a P2WPKH output if this script is a script pubkey
+        /// for a P2WPKH output. The `scriptCode` is described in [BIP-0143].
+        ///
+        /// While the type returned is [`WitnessScriptBuf`], this is **not** a witness script and
+        /// should not be used as one. It is a special template defined in BIP 143 which is used
+        /// in place of a witness script for purposes of sighash computation.
+        ///
+        /// [BIP-0143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
+        fn p2wpkh_script_code(&self) -> Option<WitnessScriptBuf>
+        where T: ScriptHashableTag
+        {
+            if self.is_p2wpkh() {
+                // The `self` script is 0x00, 0x14, <pubkey_hash>
+                let bytes = <[u8; 20]>::try_from(&self.as_bytes()[2..]).expect("length checked in is_p2wpkh()");
+                let wpkh = WPubkeyHash::from_byte_array(bytes);
+                Some(script::p2wpkh_script_code(wpkh))
+            } else {
+                None
+            }
         }
 
         /// Returns witness version of the script, if any, assuming the script is a `scriptPubkey`.
@@ -56,12 +202,14 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// The witness version if this script is found to conform to the SegWit rules:
         ///
-        /// > A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte
+        /// > A scriptPubKey (or redeemScript as defined in BIP-0016/P2SH) that consists of a 1-byte
         /// > push opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new
         /// > special meaning. The value of the first push is called the "version byte". The following
         /// > byte vector pushed is called the "witness program".
         #[inline]
-        fn witness_version(&self) -> Option<WitnessVersion> {
+        fn witness_version(&self) -> Option<WitnessVersion>
+        where T: ScriptHashableTag
+        {
             let script_len = self.len();
             if !(4..=42).contains(&script_len) {
                 return None;
@@ -81,6 +229,86 @@ crate::internal_macros::define_extension_trait! {
             WitnessVersion::try_from(ver_opcode).ok()
         }
 
+        /// Checks whether a script pubkey is a P2WSH output.
+        #[inline]
+        fn is_p2wsh(&self) -> bool
+        where T: ScriptHashableTag
+        {
+            self.len() == 34
+                && self.witness_version() == Some(WitnessVersion::V0)
+                && self.as_bytes()[1] == OP_PUSHBYTES_32.to_u8()
+        }
+
+        /// Checks whether a script pubkey is a P2WPKH output.
+        #[inline]
+        fn is_p2wpkh(&self) -> bool
+        where T: ScriptHashableTag
+        {
+            self.len() == 22
+                && self.witness_version() == Some(WitnessVersion::V0)
+                && self.as_bytes()[1] == OP_PUSHBYTES_20.to_u8()
+        }
+    }
+}
+
+internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`WitnessScript`] type.
+    pub trait WitnessScriptExt impl for WitnessScript {
+        /// Returns 256-bit hash of the script for P2WSH outputs.
+        #[inline]
+        fn wscript_hash(&self) -> Result<WScriptHash, WitnessScriptSizeError> {
+            WScriptHash::from_script(self)
+        }
+
+        /// Computes the P2WSH output corresponding to this witnessScript (aka the "witness redeem
+        /// script").
+        fn to_p2wsh(&self) -> Result<ScriptPubKeyBuf, WitnessScriptSizeError> {
+            self.wscript_hash().map(ScriptPubKeyBuf::new_p2wsh)
+        }
+    }
+}
+
+crate::internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`TapScript`] type.
+    pub trait TapScriptExt impl for TapScript {
+        /// Computes leaf hash of tapscript.
+        #[inline]
+        fn tapscript_leaf_hash(&self) -> TapLeafHash {
+            TapLeafHash::from_script(self, LeafVersion::TapScript)
+        }
+
+        /// Computes P2TR output with a given internal key and a single script spending path equal to
+        /// the current script, assuming that the script is a Tapscript.
+        fn to_p2tr<K: Into<UntweakedPublicKey>>(
+            &self,
+            internal_key: K,
+        ) -> ScriptPubKeyBuf {
+            let internal_key = internal_key.into();
+            let leaf_hash = self.tapscript_leaf_hash();
+            let merkle_root = TapNodeHash::from(leaf_hash);
+            ScriptPubKeyBuf::new_p2tr(internal_key, Some(merkle_root))
+        }
+    }
+}
+
+internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`ScriptPubKey`] type.
+    pub trait ScriptPubKeyExt impl for ScriptPubKey {
+        /// Checks whether a script pubkey is a P2PK output.
+        ///
+        /// You can obtain the public key, if it's valid,
+        /// by calling [`p2pk_public_key()`](Self::p2pk_public_key)
+        fn is_p2pk(&self) -> bool { self.p2pk_pubkey_bytes().is_some() }
+
+        /// Returns the public key if this script is P2PK with a **valid** public key.
+        ///
+        /// This may return `None` even when [`is_p2pk()`](Self::is_p2pk) returns true.
+        /// This happens when the public key is invalid (e.g. the point not being on the curve).
+        /// In this situation the script is unspendable.
+        fn p2pk_public_key(&self) -> Option<PublicKey> {
+            PublicKey::from_slice(self.p2pk_pubkey_bytes()?).ok()
+        }
+
         /// Checks whether a script pubkey is a P2SH output.
         #[inline]
         fn is_p2sh(&self) -> bool {
@@ -101,25 +329,6 @@ crate::internal_macros::define_extension_trait! {
                 && self.as_bytes()[24] == OP_CHECKSIG.to_u8()
         }
 
-        /// Checks whether a script is push only.
-        ///
-        /// Note: `OP_RESERVED` (`0x50`) and all the OP_PUSHNUM operations
-        /// are considered push operations.
-        #[inline]
-        fn is_push_only(&self) -> bool {
-            for inst in self.instructions() {
-                match inst {
-                    Err(_) => return false,
-                    Ok(Instruction::PushBytes(_)) => {}
-                    Ok(Instruction::Op(op)) if op.to_u8() <= 0x60 => {}
-                    // From Bitcoin Core
-                    // if (opcode > OP_PUSHNUM_16 (0x60)) return false
-                    Ok(Instruction::Op(_)) => return false,
-                }
-            }
-            true
-        }
-
         /// Checks whether a script pubkey is a bare multisig output.
         ///
         /// In a bare multisig pubkey script the keys are not hashed, the script
@@ -177,28 +386,21 @@ crate::internal_macros::define_extension_trait! {
         #[inline]
         fn is_witness_program(&self) -> bool { self.witness_version().is_some() }
 
-        /// Checks whether a script pubkey is a P2WSH output.
+        /// Checks whether a script pubkey is a P2TR output.
         #[inline]
-        fn is_p2wsh(&self) -> bool {
+        fn is_p2tr(&self) -> bool {
             self.len() == 34
-                && self.witness_version() == Some(WitnessVersion::V0)
+                && self.witness_version() == Some(WitnessVersion::V1)
                 && self.as_bytes()[1] == OP_PUSHBYTES_32.to_u8()
         }
 
-        /// Checks whether a script pubkey is a P2WPKH output.
+        /// Checks whether a script pubkey is a P2A output.
         #[inline]
-        fn is_p2wpkh(&self) -> bool {
-            self.len() == 22
-                && self.witness_version() == Some(WitnessVersion::V0)
-                && self.as_bytes()[1] == OP_PUSHBYTES_20.to_u8()
-        }
-
-        /// Checks whether a script pubkey is a P2TR output.
-        #[inline]
-        fn is_p2tr(&self) -> bool {
-            self.len() == 34
+        fn is_p2a(&self) -> bool {
+            self.len() == 4
                 && self.witness_version() == Some(WitnessVersion::V1)
-                && self.as_bytes()[1] == OP_PUSHBYTES_32.to_u8()
+                && self.as_bytes()[1] == OP_PUSHBYTES_2.to_u8()
+                && self.as_bytes()[2..] == P2A_PROGRAM
         }
 
         /// Check if this is a consensus-valid OP_RETURN output.
@@ -207,10 +409,7 @@ crate::internal_macros::define_extension_trait! {
         /// [`is_standard_op_return()`](Self::is_standard_op_return) instead.
         #[inline]
         fn is_op_return(&self) -> bool {
-            match self.as_bytes().first() {
-                Some(b) => *b == OP_RETURN.to_u8(),
-                None => false,
-            }
+            self.as_bytes().first().is_some_and(|&b| b == OP_RETURN.to_u8())
         }
 
         /// Check if this is an OP_RETURN that obeys Bitcoin Core standardness policy.
@@ -240,25 +439,6 @@ crate::internal_macros::define_extension_trait! {
             }
         }
 
-        /// Get redeemScript following BIP16 rules regarding P2SH spending.
-        ///
-        /// This does not guarantee that this represents a P2SH input [`Script`].
-        /// It merely gets the last push of the script.
-        ///
-        /// Use [`Script::is_p2sh`] on the scriptPubKey to check whether it is actually a P2SH script.
-        fn redeem_script(&self) -> Option<&Script> {
-            // Script must consist entirely of pushes.
-            if self.instructions().any(|i| i.is_err() || i.unwrap().push_bytes().is_none()) {
-                return None;
-            }
-
-            if let Some(Ok(Instruction::PushBytes(b))) = self.instructions().last() {
-                Some(Script::from_bytes(b.as_bytes()))
-            } else {
-                None
-            }
-        }
-
         /// Returns the minimum value an output with this script should have in order to be
         /// broadcastable on today’s Bitcoin network.
         #[deprecated(since = "0.32.0", note = "use `minimal_non_dust` etc. instead")]
@@ -272,7 +452,7 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// To use a custom value, use [`minimal_non_dust_custom`].
         ///
-        /// [`minimal_non_dust_custom`]: Script::minimal_non_dust_custom
+        /// [`minimal_non_dust_custom`]: Self::minimal_non_dust_custom
         fn minimal_non_dust(&self) -> Amount {
             self.minimal_non_dust_internal(DUST_RELAY_TX_FEE.into())
                 .expect("dust_relay_fee or script length should not be absurdly large")
@@ -288,147 +468,20 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// To use the default Bitcoin Core value, use [`minimal_non_dust`].
         ///
-        /// [`minimal_non_dust`]: Script::minimal_non_dust
-        fn minimal_non_dust_custom(&self, dust_relay_fee: FeeRate) -> Option<Amount> {
-            self.minimal_non_dust_internal(dust_relay_fee.to_sat_per_kwu() * 4)
-        }
-
-        /// Counts the sigops for this Script using accurate counting.
-        ///
-        /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
-        /// This method uses "accurate" counting. This means that OP_CHECKMULTISIG and its
-        /// verify variant count for N sigops where N is the number of pubkeys used in the
-        /// multisig. However, it will count for 20 sigops if CHECKMULTISIG is not preceded by an
-        /// OP_PUSHNUM from 1 - 16 (this would be an invalid script)
-        ///
-        /// Bitcoin Core uses accurate counting for sigops contained within redeemScripts (P2SH)
-        /// and witnessScripts (P2WSH) only. It uses legacy for sigops in scriptSigs and scriptPubkeys.
-        ///
-        /// (Note: Taproot scripts don't count toward the sigop count of the block,
-        /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
-        /// so do not use this to try and estimate if a Taproot script goes over the sigop budget.)
-        fn count_sigops(&self) -> usize { self.count_sigops_internal(true) }
-
-        /// Counts the sigops for this Script using legacy counting.
-        ///
-        /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
-        /// This method uses "legacy" counting. This means that OP_CHECKMULTISIG and its
-        /// verify variant count for 20 sigops.
-        ///
-        /// Bitcoin Core uses legacy counting for sigops contained within scriptSigs and
-        /// scriptPubkeys. It uses accurate for redeemScripts (P2SH) and witnessScripts (P2WSH).
-        ///
-        /// (Note: Taproot scripts don't count toward the sigop count of the block,
-        /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
-        /// so do not use this to try and estimate if a Taproot script goes over the sigop budget.)
-        fn count_sigops_legacy(&self) -> usize { self.count_sigops_internal(false) }
-
-        /// Iterates over the script instructions.
-        ///
-        /// Each returned item is a nested enum covering opcodes, datapushes and errors.
-        /// At most one error will be returned and then the iterator will end. To instead iterate over
-        /// the script as sequence of bytes call the [`bytes`](Self::bytes) method.
-        ///
-        /// To force minimal pushes, use [`instructions_minimal`](Self::instructions_minimal).
-        #[inline]
-        fn instructions(&self) -> Instructions {
-            Instructions { data: self.as_bytes().iter(), enforce_minimal: false }
-        }
-
-        /// Iterates over the script instructions while enforcing minimal pushes.
-        ///
-        /// This is similar to [`instructions`](Self::instructions) but an error is returned if a push
-        /// is not minimal.
-        #[inline]
-        fn instructions_minimal(&self) -> Instructions {
-            Instructions { data: self.as_bytes().iter(), enforce_minimal: true }
-        }
-
-        /// Iterates over the script instructions and their indices.
-        ///
-        /// Unless the script contains an error, the returned item consists of an index pointing to the
-        /// position in the script where the instruction begins and the decoded instruction - either an
-        /// opcode or data push.
-        ///
-        /// To force minimal pushes, use [`Self::instruction_indices_minimal`].
-        #[inline]
-        fn instruction_indices(&self) -> InstructionIndices {
-            InstructionIndices::from_instructions(self.instructions())
-        }
-
-        /// Iterates over the script instructions and their indices while enforcing minimal pushes.
-        ///
-        /// This is similar to [`instruction_indices`](Self::instruction_indices) but an error is
-        /// returned if a push is not minimal.
-        #[inline]
-        fn instruction_indices_minimal(&self) -> InstructionIndices {
-            InstructionIndices::from_instructions(self.instructions_minimal())
-        }
-
-        /// Writes the human-readable assembly representation of the script to the formatter.
-        #[deprecated(since = "TBD", note = "use the script's `Display` impl instead")]
-        fn fmt_asm(&self, f: &mut dyn fmt::Write) -> fmt::Result {
-            write!(f, "{}", self)
-        }
-
-        /// Returns the human-readable assembly representation of the script.
-        #[deprecated(since = "TBD", note = "use `to_string()` instead")]
-        fn to_asm_string(&self) -> String { self.to_string() }
-
-        /// Consensus encodes the script as lower-case hex.
-        #[deprecated(since = "TBD", note = "use `to_hex_string_no_length_prefix` instead")]
-        fn to_hex_string(&self) -> String { self.to_hex_string_no_length_prefix() }
-
-        /// Consensus encodes the script as lower-case hex.
-        ///
-        /// Consensus encoding includes a length prefix. To hex encode without the length prefix use
-        /// `to_hex_string_no_length_prefix`.
-        fn to_hex_string_prefixed(&self) -> String { consensus::encode::serialize_hex(self) }
-
-        /// Encodes the script as lower-case hex.
-        ///
-        /// This is **not** consensus encoding. The returned hex string will not include the length
-        /// prefix. See `to_hex_string_prefixed`.
-        fn to_hex_string_no_length_prefix(&self) -> String {
-            self.as_bytes().to_lower_hex_string()
-        }
-
-        /// Returns the first opcode of the script (if there is any).
-        fn first_opcode(&self) -> Option<Opcode> {
-            self.as_bytes().first().copied().map(From::from)
+        /// [`minimal_non_dust`]: Self::minimal_non_dust
+        fn minimal_non_dust_custom(&self, dust_relay: FeeRate) -> Option<Amount> {
+            self.minimal_non_dust_internal(dust_relay.to_sat_per_kvb_ceil())
         }
     }
 }
 
 mod sealed {
     pub trait Sealed {}
-    impl Sealed for super::Script {}
+    impl<T> Sealed for super::Script<T> {}
 }
 
-crate::internal_macros::define_extension_trait! {
-    pub(crate) trait ScriptExtPriv impl for Script {
-        fn minimal_non_dust_internal(&self, dust_relay_fee: u64) -> Option<Amount> {
-            // This must never be lower than Bitcoin Core's GetDustThreshold() (as of v0.21) as it may
-            // otherwise allow users to create transactions which likely can never be broadcast/confirmed.
-            let sats = dust_relay_fee
-                .checked_mul(if self.is_op_return() {
-                    0
-                } else if self.is_witness_program() {
-                    32 + 4 + 1 + (107 / 4) + 4 + // The spend cost copied from Core
-                    8 + // The serialized size of the TxOut's amount field
-                    self.consensus_encode(&mut sink()).expect("sinks don't error").to_u64() // The serialized size of this script_pubkey
-                } else {
-                    32 + 4 + 1 + 107 + 4 + // The spend cost copied from Core
-                    8 + // The serialized size of the TxOut's amount field
-                    self.consensus_encode(&mut sink()).expect("sinks don't error").to_u64() // The serialized size of this script_pubkey
-                })?
-                / 1000; // divide by 1000 like in Core to get value as it cancels out DEFAULT_MIN_RELAY_TX_FEE
-                        // Note: We ensure the division happens at the end, since Core performs the division at the end.
-                        //       This will make sure none of the implicit floor operations mess with the value.
-
-            Amount::from_sat(sats).ok()
-        }
-
+internal_macros::define_extension_trait! {
+    pub(crate) trait ScriptExtPriv<T> impl<T> for Script<T> {
         fn count_sigops_internal(&self, accurate: bool) -> usize {
             let mut n = 0;
             let mut pushnum_cache = None;
@@ -471,7 +524,7 @@ crate::internal_macros::define_extension_trait! {
 
         /// Iterates the script to find the last opcode.
         ///
-        /// Returns `None` is the instruction is data push or if the script is empty.
+        /// Returns `None` if the instruction is data push or if the script is empty.
         fn last_opcode(&self) -> Option<Opcode> {
             match self.instructions().last() {
                 Some(Ok(Instruction::Op(op))) => Some(op),
@@ -484,7 +537,10 @@ crate::internal_macros::define_extension_trait! {
         /// Returns `None` if the instruction is an opcode or if the script is empty.
         fn last_pushdata(&self) -> Option<&PushBytes> {
             match self.instructions().last() {
-                // Handles op codes up to (but excluding) OP_PUSHNUM_NEG.
+                // Returns only true data pushes.
+                // Note: OP_0 (empty push) is included as PushBytes; numeric push opcodes
+                // OP_1NEGATE and OP_1..OP_16 are opcodes (not pushdata) and thus excluded.
+                // OP_RESERVED is also excluded.
                 Some(Ok(Instruction::PushBytes(bytes))) => Some(bytes),
                 // OP_16 (0x60) and lower are considered "pushes" by Bitcoin Core (excl. OP_RESERVED).
                 // However we are only interested in the pushdata so we can ignore them.
@@ -494,6 +550,71 @@ crate::internal_macros::define_extension_trait! {
     }
 }
 
+internal_macros::define_extension_trait! {
+    pub(crate) trait ScriptPubKeyExtPriv impl for ScriptPubKey {
+        /// Returns the bytes of the (possibly invalid) public key if this script is P2PK.
+        fn p2pk_pubkey_bytes(&self) -> Option<&[u8]> {
+            if let Ok(bytes) = <&[u8; 67]>::try_from(self.as_bytes()) {
+                let (&first, bytes) = bytes.split_first::<66>();
+                let (&last, pubkey) = bytes.split_last::<65>();
+                (first == OP_PUSHBYTES_65.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
+            } else if let Ok(bytes) = <&[u8; 35]>::try_from(self.as_bytes()) {
+                let (&first, bytes) = bytes.split_first::<34>();
+                let (&last, pubkey) = bytes.split_last::<33>();
+                (first == OP_PUSHBYTES_33.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
+            } else {
+                None
+            }
+        }
+
+        fn minimal_non_dust_internal(&self, dust_relay_fee_rate_per_kvb: u64) -> Option<Amount> {
+            // This must never be lower than Bitcoin Core's GetDustThreshold() (as of v0.21) as it may
+            // otherwise allow users to create transactions which likely can never be broadcast/confirmed.
+            let sats = dust_relay_fee_rate_per_kvb
+                .checked_mul(if self.is_op_return() {
+                    0
+                } else if self.is_witness_program() {
+                    32 + 4 + 1 + (107 / 4) + 4 + // The spend cost copied from Core
+                    8 + // The serialized size of the TxOut's amount field
+                    self.consensus_encode(&mut sink()).expect("sinks don't error").to_u64() // The serialized size of this script_pubkey
+                } else {
+                    32 + 4 + 1 + 107 + 4 + // The spend cost copied from Core
+                    8 + // The serialized size of the TxOut's amount field
+                    self.consensus_encode(&mut sink()).expect("sinks don't error").to_u64() // The serialized size of this script_pubkey
+                })?
+                / 1000; // divide by 1000 like in Core to get value as it cancels out DEFAULT_MIN_RELAY_TX_FEE
+                        // Note: We ensure the division happens at the end, since Core performs the division at the end.
+                        //       This will make sure none of the implicit floor operations mess with the value.
+
+            Amount::from_sat(sats).ok()
+        }
+    }
+}
+
+internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`ScriptSig`] type.
+    pub trait ScriptSigExt impl for ScriptSig {
+        /// Get redeemScript following BIP-0016 rules regarding P2SH spending.
+        ///
+        /// This does not guarantee that this represents a P2SH input [`ScriptSig`].
+        /// It merely gets the last push of the script.
+        ///
+        /// Use [`ScriptPubKey::is_p2sh`] on the scriptPubKey to check whether it is actually a P2SH script.
+        fn redeem_script(&self) -> Option<&RedeemScript> {
+            // Script must consist entirely of pushes.
+            if self.instructions().any(|i| i.is_err() || i.unwrap().push_bytes().is_none()) {
+                return None;
+            }
+
+            if let Some(Ok(Instruction::PushBytes(b))) = self.instructions().last() {
+                Some(RedeemScript::from_bytes(b.as_bytes()))
+            } else {
+                None
+            }
+        }
+    }
+}
+
 /// Iterator over bytes of a script
 pub struct Bytes<'a>(core::iter::Copied<core::slice::Iter<'a, u8>>);
 
diff --git a/bitcoin/src/blockdata/script/builder.rs b/bitcoin/src/blockdata/script/builder.rs
index 55d4c325a5..ec7786140d 100644
--- a/bitcoin/src/blockdata/script/builder.rs
+++ b/bitcoin/src/blockdata/script/builder.rs
@@ -2,30 +2,32 @@
 
 use core::fmt;
 
-use primitives::relative;
-
-use super::{opcode_to_verify, write_scriptint, Error, PushBytes, Script, ScriptBuf};
+use super::{opcode_to_verify, Error, PushBytes, Script, ScriptBuf};
+use crate::key::{PublicKey, XOnlyPublicKey};
 use crate::locktime::absolute;
 use crate::opcodes::all::*;
 use crate::opcodes::Opcode;
 use crate::prelude::Vec;
 use crate::script::{ScriptBufExt as _, ScriptBufExtPriv as _, ScriptExtPriv as _};
-use crate::Sequence;
+use crate::{relative, Sequence};
 
 /// An Object which can be used to construct a script piece by piece.
+///
+/// # Panics
+///
+/// `Builder` is backed by [`ScriptBuf`] and inherits its panic behavior. This means that
+/// attempting to construct scripts larger than `isize::MAX` bytes will panic.
 #[derive(PartialEq, Eq, Clone)]
-pub struct Builder(ScriptBuf, Option<Opcode>);
+pub struct Builder<T>(ScriptBuf<T>, Option<Opcode>);
 
-impl Builder {
+impl<T> Builder<T> {
     /// Constructs a new empty script.
     #[inline]
-    pub const fn new() -> Self { Builder(ScriptBuf::new(), None) }
+    pub const fn new() -> Self { Self(ScriptBuf::new(), None) }
 
     /// Constructs a new empty script builder with at least the specified capacity.
     #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Builder(ScriptBuf::with_capacity(capacity), None)
-    }
+    pub fn with_capacity(capacity: usize) -> Self { Self(ScriptBuf::with_capacity(capacity), None) }
 
     /// Returns the length in bytes of the script.
     pub fn len(&self) -> usize { self.0.len() }
@@ -41,13 +43,10 @@ impl Builder {
     /// # Errors
     ///
     /// Only errors if `data == i32::MIN` (CScriptNum cannot have value -2^31).
-    pub fn push_int(self, n: i32) -> Result<Builder, Error> {
-        if n == i32::MIN {
-            // ref: https://github.com/bitcoin/bitcoin/blob/cac846c2fbf6fc69bfc288fd387aa3f68d84d584/src/script/script.h#L230
-            Err(Error::NumericOverflow)
-        } else {
-            Ok(self.push_int_unchecked(n.into()))
-        }
+    pub fn push_int(mut self, n: i32) -> Result<Self, Error> {
+        self.0.push_int(n)?;
+        self.1 = None;
+        Ok(self)
     }
 
     /// Adds instructions to push an unchecked integer onto the stack.
@@ -65,37 +64,36 @@ impl Builder {
     /// > throwing an exception if arithmetic is done or the result is interpreted as an integer.
     ///
     /// Does not check whether `n` is in the range of [-2^31 +1...2^31 -1].
-    pub fn push_int_unchecked(self, n: i64) -> Builder {
-        match n {
-            -1 => self.push_opcode(OP_PUSHNUM_NEG1),
-            0 => self.push_opcode(OP_PUSHBYTES_0),
-            1..=16 => self.push_opcode(Opcode::from(n as u8 + (OP_PUSHNUM_1.to_u8() - 1))),
-            _ => self.push_int_non_minimal(n),
-        }
+    pub fn push_int_unchecked(mut self, n: i64) -> Self {
+        self.0.push_int_unchecked(n);
+        self.1 = None;
+        self
     }
 
     /// Adds instructions to push an integer onto the stack without optimization.
     ///
     /// This uses the explicit encoding regardless of the availability of dedicated opcodes.
-    pub(in crate::blockdata) fn push_int_non_minimal(self, data: i64) -> Builder {
-        let mut buf = [0u8; 8];
-        let len = write_scriptint(&mut buf, data);
-        self.push_slice_non_minimal(&<&PushBytes>::from(&buf)[..len])
+    pub(in crate::blockdata) fn push_int_non_minimal(mut self, data: i64) -> Self {
+        self.0.push_int_non_minimal(data);
+        self.1 = None;
+        self
     }
 
     /// Adds instructions to push some arbitrary data onto the stack.
-    pub fn push_slice<T: AsRef<PushBytes>>(self, data: T) -> Builder {
-        let bytes = data.as_ref().as_bytes();
-        if bytes.len() == 1 && (bytes[0] == 0x81 || bytes[0] <= 16) {
-            match bytes[0] {
-                0x81 => self.push_opcode(OP_PUSHNUM_NEG1),
-                0 => self.push_opcode(OP_PUSHBYTES_0),
-                1..=16 => self.push_opcode(Opcode::from(bytes[0] + (OP_PUSHNUM_1.to_u8() - 1))),
-                _ => self, // unreachable arm
-            }
-        } else {
-            self.push_slice_non_minimal(data.as_ref())
-        }
+    ///
+    /// If the data can be exactly produced by a numeric opcode, that opcode
+    /// will be used, since its behavior is equivalent but will not violate minimality
+    /// rules. To avoid this, use [`Builder::push_slice_non_minimal`] which will always
+    /// use a push opcode.
+    ///
+    /// However, this method does *not* enforce any numeric minimality rules.
+    /// If your pushes should be interpreted as numbers, ensure your input does
+    /// not have any leading zeros. In particular, the number 0 should be encoded
+    /// as an empty string rather than as a single 0 byte.
+    pub fn push_slice<D: AsRef<PushBytes>>(mut self, data: D) -> Self {
+        self.0.push_slice(data);
+        self.1 = None;
+        self
     }
 
     /// Adds instructions to push some arbitrary data onto the stack without minimality.
@@ -103,14 +101,14 @@ impl Builder {
     /// Standardness rules require push minimality according to [CheckMinimalPush] of core.
     ///
     /// [CheckMinimalPush]: <https://github.com/bitcoin/bitcoin/blob/99a4ddf5ab1b3e514d08b90ad8565827fda7b63b/src/script/script.cpp#L366>
-    pub fn push_slice_non_minimal<T: AsRef<PushBytes>>(mut self, data: T) -> Builder {
+    pub fn push_slice_non_minimal<D: AsRef<PushBytes>>(mut self, data: D) -> Self {
         self.0.push_slice_non_minimal(data);
         self.1 = None;
         self
     }
 
     /// Adds a single opcode to the script.
-    pub fn push_opcode(mut self, data: Opcode) -> Builder {
+    pub fn push_opcode(mut self, data: Opcode) -> Self {
         self.0.push_opcode(data);
         self.1 = Some(data);
         self
@@ -126,7 +124,7 @@ impl Builder {
     /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
     /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
     /// semantics.
-    pub fn push_verify(mut self) -> Builder {
+    pub fn push_verify(mut self) -> Self {
         // "duplicated code" because we need to update `1` field
         match opcode_to_verify(self.1) {
             Some(opcode) => {
@@ -137,8 +135,22 @@ impl Builder {
         }
     }
 
+    /// Adds instructions to push a public key onto the stack.
+    pub fn push_key(self, key: PublicKey) -> Self {
+        if key.compressed {
+            self.push_slice(key.inner.serialize())
+        } else {
+            self.push_slice(key.inner.serialize_uncompressed())
+        }
+    }
+
+    /// Adds instructions to push an XOnly public key onto the stack.
+    pub fn push_x_only_key(self, x_only_key: XOnlyPublicKey) -> Self {
+        self.push_slice(x_only_key.serialize())
+    }
+
     /// Adds instructions to push an absolute lock time onto the stack.
-    pub fn push_lock_time(self, lock_time: absolute::LockTime) -> Builder {
+    pub fn push_lock_time(self, lock_time: absolute::LockTime) -> Self {
         self.push_int_unchecked(lock_time.to_consensus_u32().into())
     }
 
@@ -146,7 +158,7 @@ impl Builder {
     ///
     /// This is used when creating scripts that use CHECKSEQUENCEVERIFY (CSV) to enforce
     /// relative time locks.
-    pub fn push_relative_lock_time(self, lock_time: relative::LockTime) -> Builder {
+    pub fn push_relative_lock_time(self, lock_time: relative::LockTime) -> Self {
         self.push_int_unchecked(lock_time.to_consensus_u32().into())
     }
 
@@ -162,40 +174,40 @@ impl Builder {
         since = "TBD",
         note = "Use push_relative_lock_time instead for working with timelocks in scripts"
     )]
-    pub fn push_sequence(self, sequence: Sequence) -> Builder {
+    pub fn push_sequence(self, sequence: Sequence) -> Self {
         self.push_int_unchecked(sequence.to_consensus_u32().into())
     }
 
     /// Converts the `Builder` into `ScriptBuf`.
-    pub fn into_script(self) -> ScriptBuf { self.0 }
+    pub fn into_script(self) -> ScriptBuf<T> { self.0 }
 
     /// Converts the `Builder` into script bytes
     pub fn into_bytes(self) -> Vec<u8> { self.0.into() }
 
     /// Returns the internal script
-    pub fn as_script(&self) -> &Script { &self.0 }
+    pub fn as_script(&self) -> &Script<T> { &self.0 }
 
     /// Returns script bytes
     pub fn as_bytes(&self) -> &[u8] { self.0.as_bytes() }
 }
 
-impl Default for Builder {
-    fn default() -> Builder { Builder::new() }
+impl<T> Default for Builder<T> {
+    fn default() -> Self { Self::new() }
 }
 
 /// Constructs a new builder from an existing vector.
-impl From<Vec<u8>> for Builder {
-    fn from(v: Vec<u8>) -> Builder {
+impl<T> From<Vec<u8>> for Builder<T> {
+    fn from(v: Vec<u8>) -> Self {
         let script = ScriptBuf::from(v);
         let last_op = script.last_opcode();
-        Builder(script, last_op)
+        Self(script, last_op)
     }
 }
 
-impl fmt::Display for Builder {
+impl<T> fmt::Display for Builder<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
-impl fmt::Debug for Builder {
+impl<T> fmt::Debug for Builder<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
 }
diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 16cd1df458..e7037591a9 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -2,7 +2,7 @@
 
 use internals::script::{self, PushDataLenLen};
 
-use super::{Error, PushBytes, Script, ScriptBuf, ScriptBufExtPriv as _};
+use super::{Error, PushBytes, Script, ScriptBufExtPriv as _};
 use crate::opcodes::{self, Opcode};
 
 /// A "parsed opcode" which allows iterating over a [`Script`] in a more sensible way.
@@ -48,7 +48,7 @@ impl Instruction<'_> {
                 }
             }
             Instruction::PushBytes(bytes) =>
-                super::read_scriptint_non_minimal(bytes.as_bytes()).ok(),
+                super::read_scriptint_non_minimal(bytes.as_bytes()).ok().map(i64::from),
         }
     }
 
@@ -56,7 +56,10 @@ impl Instruction<'_> {
     pub(super) fn script_serialized_len(&self) -> usize {
         match self {
             Instruction::Op(_) => 1,
-            Instruction::PushBytes(bytes) => ScriptBuf::reserved_len_for_slice(bytes.len()),
+            // The use of `ScriptSigBuf` here is arbitrary. Rust insists that we pick
+            // a specific tagged script type.
+            Instruction::PushBytes(bytes) =>
+                super::ScriptSigBuf::reserved_len_for_slice(bytes.len()),
         }
     }
 
@@ -74,7 +77,7 @@ impl Instruction<'_> {
                     _ => None,
                 }
             }
-            Instruction::PushBytes(bytes) => bytes.read_scriptint().ok(),
+            Instruction::PushBytes(bytes) => bytes.read_cltv_scriptint().ok(),
         }
     }
 }
@@ -90,7 +93,10 @@ impl<'a> Instructions<'a> {
     /// Views the remaining script as a slice.
     ///
     /// This is analogous to what [`core::str::Chars::as_str`] does.
-    pub fn as_script(&self) -> &'a Script { Script::from_bytes(self.data.as_slice()) }
+    pub fn as_script<T>(&self) -> &'a Script<T> { Script::from_bytes(self.data.as_slice()) }
+
+    /// The number of remaining bytes in the script.
+    fn remaining_bytes(&self) -> usize { self.data.as_slice().len() }
 
     /// Sets the iterator to end so that it won't iterate any longer.
     pub(super) fn kill(&mut self) {
@@ -184,7 +190,7 @@ impl<'a> Iterator for Instructions<'a> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.data.len() == 0 {
+        if self.data.as_slice().is_empty() {
             (0, Some(0))
         } else {
             // There will not be more instructions than bytes
@@ -211,14 +217,14 @@ impl<'a> InstructionIndices<'a> {
     ///
     /// This is analogous to what [`core::str::Chars::as_str`] does.
     #[inline]
-    pub fn as_script(&self) -> &'a Script { self.instructions.as_script() }
+    pub fn as_script<T>(&self) -> &'a Script<T> { self.instructions.as_script() }
 
     /// Constructs a new `Self` setting `pos` to 0.
     pub(super) fn from_instructions(instructions: Instructions<'a>) -> Self {
         InstructionIndices { instructions, pos: 0 }
     }
 
-    pub(super) fn remaining_bytes(&self) -> usize { self.instructions.as_script().len() }
+    pub(super) fn remaining_bytes(&self) -> usize { self.instructions.remaining_bytes() }
 
     /// Modifies the iterator using `next_fn` returning the next item.
     ///
diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index dccfe67272..0664376922 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -2,8 +2,6 @@
 
 //! Bitcoin scripts.
 //!
-//! *[See also the `Script` type](Script).*
-//!
 //! This module provides the structures and functions needed to support scripts.
 //!
 //! <details>
@@ -11,7 +9,7 @@
 //!
 //! Scripts define Bitcoin's digital signature scheme: a signature is formed
 //! from a script (the second half of which is defined by a coin to be spent,
-//! and the first half provided by the spending transaction), and is valid iff
+//! and the first half provided by the spending transaction), and is valid if and only if
 //! the script leaves `TRUE` on the stack after being evaluated. Bitcoin's
 //! script is a stack-based assembly language similar in spirit to [Forth].
 //!
@@ -62,6 +60,7 @@ use core::fmt;
 
 use io::{BufRead, Write};
 
+use self::witness_version::WitnessVersion;
 use crate::consensus::{encode, Decodable, Encodable};
 use crate::internal_macros::impl_asref_push_bytes;
 use crate::key::WPubkeyHash;
@@ -73,15 +72,18 @@ use crate::OutPoint;
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
-    borrowed::ScriptExt,
+    borrowed::{ScriptExt, TapScriptExt, ScriptPubKeyExt, WitnessScriptExt, ScriptSigExt},
     builder::Builder,
     instruction::{Instruction, Instructions, InstructionIndices},
-    owned::ScriptBufExt,
-    push_bytes::{PushBytes, PushBytesBuf, PushBytesError, PushBytesErrorReport},
+    owned::{ScriptBufExt, ScriptPubKeyBufExt},
+    push_bytes::{PushBytes, PushBytesBuf, PushBytesError, PushBytesErrorReport, ScriptIntError},
 };
 #[doc(inline)]
 pub use primitives::script::{
-    RedeemScriptSizeError, Script, ScriptBuf, ScriptHash, WScriptHash, WitnessScriptSizeError,
+    RedeemScript, RedeemScriptBuf, RedeemScriptSizeError, RedeemScriptTag, Script, ScriptBuf,
+    ScriptHash, ScriptHashableTag, ScriptPubKey, ScriptPubKeyBuf, ScriptPubKeyTag, ScriptSig,
+    ScriptSigBuf, ScriptSigTag, Tag, TapScript, TapScriptBuf, TapScriptTag, WScriptHash,
+    WitnessScript, WitnessScriptBuf, WitnessScriptSizeError, WitnessScriptTag,
 };
 
 pub(crate) use self::borrowed::ScriptExtPriv;
@@ -89,12 +91,16 @@ pub(crate) use self::owned::ScriptBufExtPriv;
 
 impl_asref_push_bytes!(ScriptHash, WScriptHash);
 
-/// Constructs a new [`ScriptBuf`] containing the script code used for spending a P2WPKH output.
+/// Constructs a new [`WitnessScriptBuf`] containing the script code used for spending a P2WPKH output.
+///
+/// The `scriptCode` is described in [BIP-0143].
 ///
-/// The `scriptCode` is described in [BIP143].
+/// While the type returned is [`WitnessScriptBuf`], this is **not** a witness script and
+/// should not be used as one. It is a special template defined in BIP-0143 which is used
+/// in place of a witness script for purposes of sighash computation.
 ///
-/// [BIP143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
-pub fn p2wpkh_script_code(wpkh: WPubkeyHash) -> ScriptBuf {
+/// [BIP-0143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
+pub fn p2wpkh_script_code(wpkh: WPubkeyHash) -> WitnessScriptBuf {
     Builder::new()
         .push_opcode(OP_DUP)
         .push_opcode(OP_HASH160)
@@ -149,15 +155,16 @@ pub fn write_scriptint(out: &mut [u8; 8], n: i64) -> usize {
 ///
 /// See [`push_bytes::PushBytes::read_scriptint`] for a description of some subtleties of
 /// this function.
-pub fn read_scriptint_non_minimal(v: &[u8]) -> Result<i64, Error> {
+pub fn read_scriptint_non_minimal(v: &[u8]) -> Result<i32, ScriptIntError> {
     if v.is_empty() {
         return Ok(0);
     }
     if v.len() > 4 {
-        return Err(Error::NumericOverflow);
+        return Err(ScriptIntError::NumericOverflow);
     }
 
-    Ok(scriptint_parse(v))
+    let ret = scriptint_parse(v);
+    Ok(i32::try_from(ret).expect("4 bytes or less fits in an i32"))
 }
 
 // Caller to guarantee that `v` is not empty.
@@ -192,27 +199,42 @@ fn opcode_to_verify(opcode: Option<Opcode>) -> Option<Opcode> {
     })
 }
 
-impl Encodable for Script {
+/// Generates P2WSH-type of scriptPubkey with a given [`WitnessVersion`] and the program bytes.
+/// Does not do any checks on version or program length.
+///
+/// Convenience method used by `new_p2a`, `new_p2wpkh`, `new_p2wsh`, `new_p2tr`, and `new_p2tr_tweaked`.
+pub(crate) fn new_witness_program_unchecked<T: AsRef<PushBytes>, Tg>(
+    version: WitnessVersion,
+    program: T,
+) -> ScriptBuf<Tg> {
+    let program = program.as_ref();
+    debug_assert!(program.len() >= 2 && program.len() <= 40);
+    // In SegWit v0, the program must be either 20 bytes (P2WPKH) or 32 bytes (P2WSH) long.
+    debug_assert!(version != WitnessVersion::V0 || program.len() == 20 || program.len() == 32);
+    Builder::new().push_opcode(version.into()).push_slice(program).into_script()
+}
+
+impl<T> Encodable for Script<T> {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         crate::consensus::encode::consensus_encode_with_size(self.as_bytes(), w)
     }
 }
 
-impl Encodable for ScriptBuf {
+impl<T> Encodable for ScriptBuf<T> {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         self.as_script().consensus_encode(w)
     }
 }
 
-impl Decodable for ScriptBuf {
+impl<T> Decodable for ScriptBuf<T> {
     #[inline]
     fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
         r: &mut R,
     ) -> Result<Self, encode::Error> {
         let v: Vec<u8> = Decodable::consensus_decode_from_finite_reader(r)?;
-        Ok(ScriptBuf::from_bytes(v))
+        Ok(Self::from_bytes(v))
     }
 }
 
@@ -241,15 +263,13 @@ impl From<Infallible> for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Error::*;
-
-        match *self {
-            NonMinimalPush => f.write_str("non-minimal datapush"),
-            EarlyEndOfScript => f.write_str("unexpected end of script"),
-            NumericOverflow =>
+        match self {
+            Self::NonMinimalPush => f.write_str("non-minimal datapush"),
+            Self::EarlyEndOfScript => f.write_str("unexpected end of script"),
+            Self::NumericOverflow =>
                 f.write_str("numeric overflow (number on stack larger than 4 bytes)"),
-            UnknownSpentOutput(ref point) => write!(f, "unknown spent output: {}", point),
-            Serialization =>
+            Self::UnknownSpentOutput(ref point) => write!(f, "unknown spent output: {}", point),
+            Self::Serialization =>
                 f.write_str("can not serialize the spending transaction in Transaction::verify()"),
         }
     }
@@ -258,14 +278,12 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Error::*;
-
-        match *self {
-            NonMinimalPush
-            | EarlyEndOfScript
-            | NumericOverflow
-            | UnknownSpentOutput(_)
-            | Serialization => None,
+        match self {
+            Self::NonMinimalPush
+            | Self::EarlyEndOfScript
+            | Self::NumericOverflow
+            | Self::UnknownSpentOutput(_)
+            | Self::Serialization => None,
         }
     }
 }
diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index da3db6e117..b910dced7a 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -6,61 +6,91 @@ use core::ops::Deref;
 use hex::FromHex as _;
 use internals::ToU64 as _;
 
-use super::{opcode_to_verify, Builder, Instruction, PushBytes, ScriptExtPriv as _};
-use crate::consensus;
+use super::{
+    opcode_to_verify, write_scriptint, Builder, Error, Instruction, PushBytes, ScriptBuf,
+    ScriptExtPriv as _, ScriptPubKeyBuf,
+};
+use crate::key::{
+    PubkeyHash, PublicKey, TapTweak, TweakedPublicKey, UntweakedPublicKey, WPubkeyHash,
+};
 use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
 use crate::prelude::Vec;
+use crate::script::witness_program::{WitnessProgram, P2A_PROGRAM};
+use crate::script::witness_version::WitnessVersion;
+use crate::script::{self, ScriptHash, WScriptHash};
+use crate::taproot::TapNodeHash;
+use crate::{consensus, internal_macros};
 
-#[rustfmt::skip]            // Keep public re-exports separate.
-#[doc(inline)]
-pub use primitives::script::ScriptBuf;
-
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`ScriptBuf`] type.
-    pub trait ScriptBufExt impl for ScriptBuf {
+    pub trait ScriptBufExt<T> impl<T> for ScriptBuf<T> {
         /// Constructs a new script builder
-        fn builder() -> Builder { Builder::new() }
-
-        /// Generates OP_RETURN-type of scriptPubkey for the given data.
-        fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
-            Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
-        }
+        fn builder() -> Builder<T> { Builder::new() }
 
-        /// Constructs a new [`ScriptBuf`] from a hex string.
+        /// Adds instructions to push an integer onto the stack.
         ///
-        /// The input string is expected to be consensus encoded i.e., includes the length prefix.
-        fn from_hex_prefixed(s: &str) -> Result<ScriptBuf, consensus::FromHexError> {
-            consensus::encode::deserialize_hex(s)
-        }
-
-        /// Constructs a new [`ScriptBuf`] from a hex string.
-        #[deprecated(since = "TBD", note = "use `from_hex_string_no_length_prefix()` instead")]
-        fn from_hex(s: &str) -> Result<ScriptBuf, hex::HexToBytesError> {
-            Self::from_hex_no_length_prefix(s)
+        /// Integers are encoded as little-endian signed-magnitude numbers, but there are dedicated
+        /// opcodes to push some small integers.
+        ///
+        /// # Errors
+        ///
+        /// Only errors if `data == i32::MIN` (CScriptNum cannot have value -2^31).
+        fn push_int(&mut self, n: i32) -> Result<(), Error> {
+            if n == i32::MIN {
+                // ref: https://github.com/bitcoin/bitcoin/blob/cac846c2fbf6fc69bfc288fd387aa3f68d84d584/src/script/script.h#L230
+                Err(Error::NumericOverflow)
+            } else {
+                self.push_int_unchecked(n.into());
+                Ok(())
+            }
         }
 
-        /// Constructs a new [`ScriptBuf`] from a hex string.
+        /// Adds instructions to push an unchecked integer onto the stack.
         ///
-        /// This is **not** consensus encoding. If your hex string is a consensus encoded script
-        /// then use `ScriptBuf::from_hex_prefixed`.
-        fn from_hex_no_length_prefix(s: &str) -> Result<ScriptBuf, hex::HexToBytesError> {
-            let v = Vec::from_hex(s)?;
-            Ok(ScriptBuf::from_bytes(v))
+        /// Integers are encoded as little-endian signed-magnitude numbers, but there are dedicated
+        /// opcodes to push some small integers.
+        ///
+        /// This function implements `CScript::push_int64` from Core `script.h`.
+        ///
+        /// > Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte integers.
+        /// > The semantics are subtle, though: operands must be in the range [-2^31 +1...2^31 -1],
+        /// > but results may overflow (and are valid as long as they are not used in a subsequent
+        /// > numeric operation). CScriptNum enforces those semantics by storing results as
+        /// > an int64 and allowing out-of-range values to be returned as a vector of bytes but
+        /// > throwing an exception if arithmetic is done or the result is interpreted as an integer.
+        ///
+        /// Does not check whether `n` is in the range of [-2^31 +1...2^31 -1].
+        fn push_int_unchecked(&mut self, n: i64) {
+            match n {
+                -1 => self.push_opcode(OP_1NEGATE),
+                0 => self.push_opcode(OP_PUSHBYTES_0),
+                1..=16 => self.push_opcode(Opcode::from(n as u8 + (OP_1.to_u8() - 1))),
+                _ => self.push_int_non_minimal(n),
+            }
         }
 
         /// Adds a single opcode to the script.
         fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
 
         /// Adds instructions to push some arbitrary data onto the stack.
-        fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
+        ///
+        /// If the data can be exactly produced by a numeric opcode, that opcode
+        /// will be used, since its behavior is equivalent but will not violate minimality
+        /// rules. To avoid this, use [`ScriptBuf::push_slice_non_minimal`] which will always
+        /// use a push opcode.
+        ///
+        /// However, this method does *not* enforce any numeric minimality rules.
+        /// If your pushes should be interpreted as numbers, ensure your input does
+        /// not have any leading zeros. In particular, the number 0 should be encoded
+        /// as an empty string rather than as a single 0 byte.
+        fn push_slice<D: AsRef<PushBytes>>(&mut self, data: D) {
             let bytes = data.as_ref().as_bytes();
-            if bytes.len() == 1 && (bytes[0] == 0x81 || bytes[0] <= 16) {
+            if bytes.len() == 1 {
                 match bytes[0] {
-                    0x81 => { self.push_opcode(OP_PUSHNUM_NEG1); },
-                    0 => { self.push_opcode(OP_PUSHBYTES_0); },
-                    1..=16 => { self.push_opcode(Opcode::from(bytes[0] + (OP_PUSHNUM_1.to_u8() - 1))); },
-                    _ => {}, // unreachable arm
+                    0x81 => { self.push_opcode(OP_1NEGATE); },
+                    1..=16 => { self.push_opcode(Opcode::from(bytes[0] + (OP_1.to_u8() - 1))); },
+                    _ => { self.push_slice_non_minimal(data); },
                 }
             } else {
                 self.push_slice_non_minimal(data);
@@ -72,9 +102,9 @@ crate::internal_macros::define_extension_trait! {
         /// Standardness rules require push minimality according to [CheckMinimalPush] of core.
         ///
         /// [CheckMinimalPush]: <https://github.com/bitcoin/bitcoin/blob/99a4ddf5ab1b3e514d08b90ad8565827fda7b63b/src/script/script.cpp#L366>
-        fn push_slice_non_minimal<T: AsRef<PushBytes>>(&mut self, data: T) {
+        fn push_slice_non_minimal<D: AsRef<PushBytes>>(&mut self, data: D) {
             let data = data.as_ref();
-            self.reserve(ScriptBuf::reserved_len_for_slice(data.len()));
+            self.reserve(Self::reserved_len_for_slice(data.len()));
             self.push_slice_no_opt(data);
         }
 
@@ -114,20 +144,128 @@ crate::internal_macros::define_extension_trait! {
         /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
         /// multiple times.
         fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
+
+        /// Constructs a new [`ScriptBuf`] from a hex string.
+        ///
+        /// The input string is expected to be consensus encoded i.e., includes the length prefix.
+        fn from_hex_prefixed(s: &str) -> Result<Self, consensus::FromHexError>
+            where Self: Sized
+        {
+            consensus::encode::deserialize_hex(s)
+        }
+
+        /// Constructs a new [`ScriptBuf`] from a hex string.
+        #[deprecated(since = "TBD", note = "use `from_hex_no_length_prefix()` instead")]
+        fn from_hex(s: &str) -> Result<Self, hex::HexToBytesError>
+            where Self: Sized
+        {
+            Self::from_hex_no_length_prefix(s)
+        }
+
+        /// Constructs a new [`ScriptBuf`] from a hex string.
+        ///
+        /// This is **not** consensus encoding. If your hex string is a consensus encoded script
+        /// then use `ScriptBuf::from_hex_prefixed`.
+        fn from_hex_no_length_prefix(s: &str) -> Result<Self, hex::HexToBytesError>
+            where Self: Sized
+        {
+            let v = Vec::from_hex(s)?;
+            Ok(Self::from_bytes(v))
+        }
+
+        // This belongs only on RedeemScript and ScriptPubKey
+        /// Generates P2WPKH-type of scriptPubkey.
+        fn new_p2wpkh(pubkey_hash: WPubkeyHash) -> Self {
+            // pubkey hash is 20 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
+            script::new_witness_program_unchecked(WitnessVersion::V0, pubkey_hash)
+        }
+
+    }
+}
+
+crate::internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`ScriptPubKeyBuf`] type.
+    pub trait ScriptPubKeyBufExt impl for ScriptPubKeyBuf {
+        /// Generates OP_RETURN-type of scriptPubkey for the given data.
+        fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
+            Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
+        }
+
+        /// Generates P2PK-type of scriptPubkey.
+        fn new_p2pk(pubkey: PublicKey) -> Self {
+            Builder::new().push_key(pubkey).push_opcode(OP_CHECKSIG).into_script()
+        }
+
+        /// Generates P2PKH-type of scriptPubkey.
+        fn new_p2pkh(pubkey_hash: PubkeyHash) -> Self {
+            Builder::new()
+                .push_opcode(OP_DUP)
+                .push_opcode(OP_HASH160)
+                .push_slice(pubkey_hash)
+                .push_opcode(OP_EQUALVERIFY)
+                .push_opcode(OP_CHECKSIG)
+                .into_script()
+        }
+
+        /// Generates P2SH-type of scriptPubkey with a given hash of the redeem script.
+        fn new_p2sh(script_hash: ScriptHash) -> Self {
+            Builder::new()
+                .push_opcode(OP_HASH160)
+                .push_slice(script_hash)
+                .push_opcode(OP_EQUAL)
+                .into_script()
+        }
+
+        /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script.
+        fn new_p2wsh(script_hash: WScriptHash) -> Self {
+            // script hash is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
+            script::new_witness_program_unchecked(WitnessVersion::V0, script_hash)
+        }
+
+        /// Generates P2TR for script spending path using an internal public key and some optional
+        /// script tree Merkle root.
+        fn new_p2tr<K: Into<UntweakedPublicKey>>(
+            internal_key: K,
+            merkle_root: Option<TapNodeHash>,
+        ) -> Self {
+            let internal_key = internal_key.into();
+            let (output_key, _) = internal_key.tap_tweak(merkle_root);
+            // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
+            script::new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
+        }
+
+        /// Generates P2TR for key spending path for a known [`TweakedPublicKey`].
+        fn new_p2tr_tweaked(output_key: TweakedPublicKey) -> Self {
+            // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
+            script::new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
+        }
+
+        /// Generates pay to anchor output.
+        fn new_p2a() -> Self {
+            script::new_witness_program_unchecked(WitnessVersion::V1, P2A_PROGRAM)
+        }
+
+        /// Generates P2WSH-type of scriptPubkey with a given [`WitnessProgram`].
+        fn new_witness_program(witness_program: &WitnessProgram) -> Self {
+            Builder::new()
+                .push_opcode(witness_program.version().into())
+                .push_slice(witness_program.program())
+                .into_script()
+        }
     }
 }
 
 mod sealed {
     pub trait Sealed {}
-    impl Sealed for super::ScriptBuf {}
+    impl<T> Sealed for super::ScriptBuf<T> {}
 }
 
-crate::internal_macros::define_extension_trait! {
-    pub(crate) trait ScriptBufExtPriv impl for ScriptBuf {
+internal_macros::define_extension_trait! {
+    pub(crate) trait ScriptBufExtPriv<T> impl<T> for ScriptBuf<T> {
         /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
         ///
         /// Note: if the returned value leaks the original `ScriptBuf` will become empty.
-        fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
+        fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_, T> {
             let vec = core::mem::take(self).into_bytes();
             ScriptBufAsVec(self, vec)
         }
@@ -186,21 +324,31 @@ crate::internal_macros::define_extension_trait! {
                 None => self.push_opcode(OP_VERIFY),
             }
         }
+
+        /// Adds instructions to push an integer onto the stack without optimization.
+        ///
+        /// This uses the explicit encoding regardless of the availability of dedicated opcodes.
+        fn push_int_non_minimal(&mut self, data: i64) {
+            let mut buf = [0u8; 8];
+            let len = write_scriptint(&mut buf, data);
+            self.reserve(Self::reserved_len_for_slice(len));
+            self.push_slice_no_opt(&<&PushBytes>::from(&buf)[..len]);
+        }
     }
 }
 
-impl<'a> core::iter::FromIterator<Instruction<'a>> for ScriptBuf {
+impl<'a, Tg> core::iter::FromIterator<Instruction<'a>> for ScriptBuf<Tg> {
     fn from_iter<T>(iter: T) -> Self
     where
         T: IntoIterator<Item = Instruction<'a>>,
     {
-        let mut script = ScriptBuf::new();
+        let mut script = Self::new();
         script.extend(iter);
         script
     }
 }
 
-impl<'a> Extend<Instruction<'a>> for ScriptBuf {
+impl<'a, Tg> Extend<Instruction<'a>> for ScriptBuf<Tg> {
     fn extend<T>(&mut self, iter: T)
     where
         T: IntoIterator<Item = Instruction<'a>>,
@@ -241,19 +389,19 @@ impl<'a> Extend<Instruction<'a>> for ScriptBuf {
 /// In reality the backing `Vec<u8>` is swapped with an empty one and this is holding both the
 /// reference and the vec. The vec is put back when this drops so it also covers panics. (But not
 /// leaks, which is OK since we never leak.)
-pub(crate) struct ScriptBufAsVec<'a>(&'a mut ScriptBuf, Vec<u8>);
+pub(crate) struct ScriptBufAsVec<'a, T>(&'a mut ScriptBuf<T>, Vec<u8>);
 
-impl core::ops::Deref for ScriptBufAsVec<'_> {
+impl<T> core::ops::Deref for ScriptBufAsVec<'_, T> {
     type Target = Vec<u8>;
 
     fn deref(&self) -> &Self::Target { &self.1 }
 }
 
-impl core::ops::DerefMut for ScriptBufAsVec<'_> {
+impl<T> core::ops::DerefMut for ScriptBufAsVec<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target { &mut self.1 }
 }
 
-impl Drop for ScriptBufAsVec<'_> {
+impl<T> Drop for ScriptBufAsVec<'_, T> {
     fn drop(&mut self) {
         let vec = core::mem::take(&mut self.1);
         *(self.0) = ScriptBuf::from_bytes(vec);
diff --git a/bitcoin/src/blockdata/script/push_bytes.rs b/bitcoin/src/blockdata/script/push_bytes.rs
index 7fb46742af..31f1f6606f 100644
--- a/bitcoin/src/blockdata/script/push_bytes.rs
+++ b/bitcoin/src/blockdata/script/push_bytes.rs
@@ -2,14 +2,16 @@
 
 //! Contains `PushBytes` & co
 
+use core::fmt;
 use core::ops::{Deref, DerefMut};
 
+use crate::crypto::{ecdsa, taproot};
 use crate::prelude::{Borrow, BorrowMut};
 use crate::script;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
-// This is not the usual re-export, `primitive` here is an code audit thing.
+// This is not the usual re-export, `primitive` here is a code audit thing.
 pub use self::primitive::{PushBytes, PushBytesBuf};
 
 /// This module only contains required operations so that outside functions wouldn't accidentally
@@ -167,13 +169,13 @@ mod primitive {
 
                 impl From<[u8; $len]> for PushBytesBuf {
                     fn from(bytes: [u8; $len]) -> Self {
-                        PushBytesBuf(Vec::from(&bytes as &[_]))
+                        PushBytesBuf(Vec::from(&bytes))
                     }
                 }
 
                 impl<'a> From<&'a [u8; $len]> for PushBytesBuf {
                     fn from(bytes: &'a [u8; $len]) -> Self {
-                        PushBytesBuf(Vec::from(bytes as &[_]))
+                        PushBytesBuf(Vec::from(bytes))
                     }
                 }
             )*
@@ -195,10 +197,10 @@ mod primitive {
     impl PushBytesBuf {
         /// Constructs an empty `PushBytesBuf`.
         #[inline]
-        pub const fn new() -> Self { PushBytesBuf(Vec::new()) }
+        pub const fn new() -> Self { Self(Vec::new()) }
 
         /// Constructs an empty `PushBytesBuf` with reserved capacity.
-        pub fn with_capacity(capacity: usize) -> Self { PushBytesBuf(Vec::with_capacity(capacity)) }
+        pub fn with_capacity(capacity: usize) -> Self { Self(Vec::with_capacity(capacity)) }
 
         /// Reserve capacity for `additional_capacity` bytes.
         pub fn reserve(&mut self, additional_capacity: usize) {
@@ -273,7 +275,7 @@ mod primitive {
         fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
             // check len
             let _: &PushBytes = vec.as_slice().try_into()?;
-            Ok(PushBytesBuf(vec))
+            Ok(Self(vec))
         }
     }
 
@@ -293,6 +295,23 @@ impl PushBytes {
 
     /// Decodes an integer in script(minimal CScriptNum) format.
     ///
+    /// This code is based on the
+    /// [`CScriptNum` constructor in Bitcoin Core](https://github.com/bitcoin/bitcoin/blob/99a4ddf5ab1b3e514d08b90ad8565827fda7b63b/src/script/script.h#L245)
+    ///
+    /// # Errors
+    ///
+    /// * [`ScriptIntError::NumericOverflow`] if result is not in range [-2^39 +1...2^39 -1].
+    /// * [`ScriptIntError::NonMinimal`] if encoding is non-minimal.
+    pub fn read_scriptint(&self) -> Result<i32, ScriptIntError> {
+        // Cast is safe, since the function already checks for byte length > 4
+        let ret = self.read_scriptint_internal(4)?;
+        Ok(i32::try_from(ret).expect("4 bytes or less fits in an i32"))
+    }
+
+    /// Decodes an integer in script(minimal CScriptNum) format.
+    ///
+    /// This is suitable to read input values for CHECKLOCKTIMEVERIFY instructions.
+    ///
     /// Notice that this fails on overflow: the result is the same as in bitcoind, that only 4-byte
     /// signed-magnitude values may be read as numbers. They can be added or subtracted (and a long
     /// time ago, multiplied and divided), and this may result in numbers which can't be written out
@@ -300,17 +319,32 @@ impl PushBytes {
     /// bit crazy and subtle, but it makes sense: you can load 32-bit numbers and do anything with
     /// them, which back when mult/div was allowed, could result in up to a 64-bit number. We don't
     /// want overflow since that's surprising --- and we don't want numbers that don't fit in 64
-    /// bits (for efficiency on modern processors) so we simply say, anything in excess of 32 bits
-    /// is no longer a number. This is basically a ranged type implementation.
+    /// bits (for efficiency on modern processors). This function will return any value up to 40
+    /// bits in length. This is basically a ranged type implementation.
     ///
-    /// This code is based on the `CScriptNum` constructor in Bitcoin Core (see `script.h`).
-    pub fn read_scriptint(&self) -> Result<i64, script::Error> {
+    /// This code is based on the
+    /// [`CScriptNum` constructor in Bitcoin Core](https://github.com/bitcoin/bitcoin/blob/99a4ddf5ab1b3e514d08b90ad8565827fda7b63b/src/script/script.h#L245)
+    ///
+    /// # Errors
+    ///
+    /// * [`ScriptIntError::NumericOverflow`] if result is not in range [-2^39 +1...2^39 -1].
+    /// * [`ScriptIntError::NonMinimal`] if encoding is non-minimal.
+    pub fn read_cltv_scriptint(&self) -> Result<i64, ScriptIntError> {
+        self.read_scriptint_internal(5)
+    }
+
+    /// The internal implementation for reading a script integer.
+    ///
+    /// As with `read_cltv_scriptint`, this returns an i64, since that is the maximum size we might
+    /// need to return data. In practice, if the max_size parameter is 4 or less, this function
+    /// will always return a value that can fit into an i32, and can thus be safely cast.
+    fn read_scriptint_internal(&self, max_size: usize) -> Result<i64, ScriptIntError> {
         let last = match self.as_bytes().last() {
             Some(last) => last,
             None => return Ok(0),
         };
-        if self.len() > 4 {
-            return Err(script::Error::NumericOverflow);
+        if self.len() > max_size {
+            return Err(ScriptIntError::NumericOverflow);
         }
         // Comment and code copied from Bitcoin Core:
         // https://github.com/bitcoin/bitcoin/blob/447f50e4aed9a8b1d80e1891cda85801aeb80b4e/src/script/script.h#L247-L262
@@ -324,7 +358,7 @@ impl PushBytes {
             // is +-255, which encode to 0xff00 and 0xff80 respectively.
             // (big-endian).
             if self.len() <= 1 || (self[self.len() - 2] & 0x80) == 0 {
-                return Err(script::Error::NonMinimalPush);
+                return Err(ScriptIntError::NonMinimal);
             }
         }
 
@@ -361,12 +395,12 @@ impl DerefMut for PushBytesBuf {
     fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_push_bytes() }
 }
 
-impl AsRef<PushBytes> for PushBytes {
-    fn as_ref(&self) -> &PushBytes { self }
+impl AsRef<Self> for PushBytes {
+    fn as_ref(&self) -> &Self { self }
 }
 
-impl AsMut<PushBytes> for PushBytes {
-    fn as_mut(&mut self) -> &mut PushBytes { self }
+impl AsMut<Self> for PushBytes {
+    fn as_mut(&mut self) -> &mut Self { self }
 }
 
 impl AsRef<PushBytes> for PushBytesBuf {
@@ -385,6 +419,44 @@ impl BorrowMut<PushBytes> for PushBytesBuf {
     fn borrow_mut(&mut self) -> &mut PushBytes { self.as_mut_push_bytes() }
 }
 
+impl AsRef<PushBytes> for ecdsa::SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &PushBytes {
+        <&PushBytes>::try_from(<Self as AsRef<[u8]>>::as_ref(self))
+            .expect("max length 73 bytes is valid")
+    }
+}
+
+impl AsRef<PushBytes> for taproot::SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &PushBytes {
+        <&PushBytes>::try_from(<Self as AsRef<[u8]>>::as_ref(self))
+            .expect("max length 65 bytes is valid")
+    }
+}
+
+/// Possible errors that can arise from [`PushBytes::read_scriptint`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ScriptIntError {
+    /// The result is not in range [-2^31 +1...2^31 -1].
+    NumericOverflow,
+    /// The resulting encoding is non-minimal.
+    NonMinimal,
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ScriptIntError {}
+
+impl fmt::Display for ScriptIntError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::NumericOverflow => f.write_str("script integer outside of valid range"),
+            Self::NonMinimal => f.write_str("non-minimal encoded script integer"),
+        }
+    }
+}
+
 /// Reports information about failed conversion into `PushBytes`.
 ///
 /// This should not be needed by general public, except as an additional bound on `TryFrom` when
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index b1bfae4e04..5864cfdee9 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -3,18 +3,23 @@
 use hex_lit::hex;
 
 use super::*;
-use crate::address::script_pubkey::{
-    BuilderExt as _, ScriptBufExt as _, ScriptExt as _, ScriptExtPrivate as _,
-};
 use crate::consensus::encode::{deserialize, serialize};
 use crate::crypto::key::{PublicKey, XOnlyPublicKey};
+use crate::script::borrowed::{ScriptPubKeyExt as _, ScriptPubKeyExtPriv as _, TapScriptExt as _};
+use crate::script::witness_program::WitnessProgram;
+use crate::script::witness_version::WitnessVersion;
 use crate::{opcodes, Amount, FeeRate};
 
+// Tests should compile and pass no matter what these are.
+type Tag = primitives::script::ScriptSigTag;
+type Script = crate::ScriptSig;
+type ScriptBuf = crate::ScriptSigBuf;
+
 #[test]
 #[rustfmt::skip]
 fn script() {
     let mut comp = vec![];
-    let mut script = Builder::new();
+    let mut script = Builder::<Tag>::new();
     assert_eq!(script.as_bytes(), &comp[..]);
 
     // small ints
@@ -34,9 +39,10 @@ fn script() {
     // data
     script = script.push_slice(b"NRA4VR"); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
     // data & number push minimality
-    // OP_0
-    script = script.push_slice([0u8]); comp.extend([0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // 0x00 (single byte)
+    script = script.push_slice([0u8]); comp.extend([1u8, 0].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
     script = script.push_slice_non_minimal([0u8]); comp.extend([1, 0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // OP_0 (empty byte array)
     script = script.push_int(0).unwrap(); comp.extend([0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
     script = script.push_int_non_minimal(0); comp.extend([0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
     // OP_1..16
@@ -52,6 +58,12 @@ fn script() {
     script = script.push_int(-1).unwrap(); comp.extend([0x4f].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
     script = script.push_int_non_minimal(-1); comp.extend([1, 0x81].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
 
+    script = script.push_int(0x7fffffff).unwrap(); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0x7F].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int_unchecked(0x7fffffff); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0x7F].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    script = script.push_int(-0x7fffffff).unwrap(); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0xFF].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int_unchecked(-0x7fffffff); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0xFF].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
     // keys
     const KEYSTR1: &str = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
     let key = KEYSTR1[2..].parse::<PublicKey>().unwrap();
@@ -65,11 +77,50 @@ fn script() {
     script = script.push_opcode(OP_CHECKSIG); comp.push(0xACu8); assert_eq!(script.as_bytes(), &comp[..]);
 }
 
+#[test]
+#[rustfmt::skip]
+fn script_buf_push_int() {
+    let mut comp = vec![];
+    let mut script = ScriptBuf::new();
+    assert_eq!(script.as_bytes(), &comp[..]);
+
+    // small ints
+    script.push_int_unchecked(1);  comp.push(81u8); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(0);  comp.push(0u8);  assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(4);  comp.push(84u8); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(-1); comp.push(79u8); assert_eq!(script.as_bytes(), &comp[..]);
+    // forced scriptint
+    script.push_int_non_minimal(4); comp.extend([1u8, 4].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // big ints
+    script.push_int_unchecked(17); comp.extend([1u8, 17].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(10000); comp.extend([2u8, 16, 39].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // notice the sign bit set here, hence the extra zero/128 at the end
+    script.push_int_unchecked(10000000); comp.extend([4u8, 128, 150, 152, 0].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(-10000000); comp.extend([4u8, 128, 150, 152, 128].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    script.push_int(0).unwrap(); comp.extend([0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_non_minimal(0); comp.extend([0u8].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // OP_1..16
+    for n in 1..=16 {
+        script.push_int(n.into()).unwrap();  comp.extend([0x50 + n].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+        script.push_int_non_minimal(n.into());  comp.extend([1, n].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    }
+
+    script.push_int(-1).unwrap(); comp.extend([0x4f].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_non_minimal(-1); comp.extend([1, 0x81].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    script.push_int(0x7fffffff).unwrap(); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0x7F].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(0x7fffffff); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0x7F].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    script.push_int(-0x7fffffff).unwrap(); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0xFF].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script.push_int_unchecked(-0x7fffffff); comp.extend([4u8, 0xFF, 0xFF, 0xFF, 0xFF].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+}
+
 #[test]
 fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
+    let p2pk = ScriptPubKey::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
     let actual = p2pk.p2pk_pubkey_bytes().unwrap();
     assert_eq!(actual.to_vec(), key.to_vec());
 }
@@ -78,20 +129,20 @@ fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() {
 fn p2pk_pubkey_bytes_no_checksig_returns_none() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let no_checksig = Script::builder().push_key(key).into_script();
+    let no_checksig = ScriptPubKey::builder().push_key(key).into_script();
     assert_eq!(no_checksig.p2pk_pubkey_bytes(), None);
 }
 
 #[test]
 fn p2pk_pubkey_bytes_empty_script_returns_none() {
-    let empty_script = Script::builder().into_script();
+    let empty_script = ScriptPubKey::builder().into_script();
     assert!(empty_script.p2pk_pubkey_bytes().is_none());
 }
 
 #[test]
 fn p2pk_pubkey_bytes_no_key_returns_none() {
     // scripts with no key should return None
-    let no_push_bytes = Script::builder().push_opcode(OP_CHECKSIG).into_script();
+    let no_push_bytes = ScriptPubKey::builder().push_opcode(OP_CHECKSIG).into_script();
     assert!(no_push_bytes.p2pk_pubkey_bytes().is_none());
 }
 
@@ -99,7 +150,7 @@ fn p2pk_pubkey_bytes_no_key_returns_none() {
 fn p2pk_pubkey_bytes_different_op_code_returns_none() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script();
+    let different_op_code = ScriptPubKey::builder().push_key(key).push_opcode(OP_NOP).into_script();
     assert!(different_op_code.p2pk_pubkey_bytes().is_none());
 }
 
@@ -108,7 +159,7 @@ fn p2pk_pubkey_bytes_incorrect_key_size_returns_none() {
     // 63 byte key
     let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1";
     let invalid_p2pk_script =
-        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+        ScriptPubKey::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
     assert!(invalid_p2pk_script.p2pk_pubkey_bytes().is_none());
 }
 
@@ -116,7 +167,7 @@ fn p2pk_pubkey_bytes_incorrect_key_size_returns_none() {
 fn p2pk_pubkey_bytes_invalid_key_returns_some() {
     let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1ux";
     let invalid_key_script =
-        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+        ScriptPubKey::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
     assert!(invalid_key_script.p2pk_pubkey_bytes().is_some());
 }
 
@@ -124,7 +175,7 @@ fn p2pk_pubkey_bytes_invalid_key_returns_some() {
 fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() {
     let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
     let key = compressed_key_str.parse::<PublicKey>().unwrap();
-    let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
+    let p2pk = ScriptPubKey::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
     let actual = p2pk.p2pk_pubkey_bytes().unwrap();
     assert_eq!(actual.to_vec(), key.to_vec());
 }
@@ -133,7 +184,7 @@ fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() {
 fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
+    let p2pk = ScriptPubKey::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
     let actual = p2pk.p2pk_public_key().unwrap();
     assert_eq!(actual, key);
 }
@@ -142,19 +193,19 @@ fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() {
 fn p2pk_public_key_no_checksig_returns_none() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let no_checksig = Script::builder().push_key(key).into_script();
+    let no_checksig = ScriptPubKey::builder().push_key(key).into_script();
     assert_eq!(no_checksig.p2pk_public_key(), None);
 }
 
 #[test]
 fn p2pk_public_key_empty_script_returns_none() {
-    let empty_script = Script::builder().into_script();
+    let empty_script = ScriptPubKey::builder().into_script();
     assert!(empty_script.p2pk_public_key().is_none());
 }
 
 #[test]
 fn p2pk_public_key_no_key_returns_none() {
-    let no_push_bytes = Script::builder().push_opcode(OP_CHECKSIG).into_script();
+    let no_push_bytes = ScriptPubKey::builder().push_opcode(OP_CHECKSIG).into_script();
     assert!(no_push_bytes.p2pk_public_key().is_none());
 }
 
@@ -162,7 +213,7 @@ fn p2pk_public_key_no_key_returns_none() {
 fn p2pk_public_key_different_op_code_returns_none() {
     let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
     let key = key_str.parse::<PublicKey>().unwrap();
-    let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script();
+    let different_op_code = ScriptPubKey::builder().push_key(key).push_opcode(OP_NOP).into_script();
     assert!(different_op_code.p2pk_public_key().is_none());
 }
 
@@ -170,7 +221,7 @@ fn p2pk_public_key_different_op_code_returns_none() {
 fn p2pk_public_key_incorrect_size_returns_none() {
     let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1";
     let malformed_key_script =
-        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+        ScriptPubKey::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
     assert!(malformed_key_script.p2pk_public_key().is_none());
 }
 
@@ -178,7 +229,7 @@ fn p2pk_public_key_incorrect_size_returns_none() {
 fn p2pk_public_key_invalid_key_returns_none() {
     let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1ux";
     let invalid_key_script =
-        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+        ScriptPubKey::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
     assert!(invalid_key_script.p2pk_public_key().is_none());
 }
 
@@ -186,7 +237,7 @@ fn p2pk_public_key_invalid_key_returns_none() {
 fn p2pk_public_key_compressed_key_returns_some() {
     let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
     let key = compressed_key_str.parse::<PublicKey>().unwrap();
-    let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
+    let p2pk = ScriptPubKey::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
     let actual = p2pk.p2pk_public_key().unwrap();
     assert_eq!(actual, key);
 }
@@ -198,14 +249,14 @@ fn script_x_only_key() {
     // From: https://github.com/bitcoin-core/btcdeb/blob/e8c2750c4a4702768c52d15640ed03bf744d2601/doc/tapscript-example.md?plain=1#L43
     const KEYSTR: &str = "209997a497d964fc1a62885b05a51166a65a90df00492c8d7cf61d6accf54803be";
     let x_only_key = KEYSTR[2..].parse::<XOnlyPublicKey>().unwrap();
-    let script = Builder::new().push_x_only_key(x_only_key);
+    let script = Builder::<Tag>::new().push_x_only_key(x_only_key);
     assert_eq!(script.into_bytes(), &hex!(KEYSTR) as &[u8]);
 }
 
 #[test]
 fn script_builder() {
     // from txid 3bb5e6434c11fb93f64574af5d116736510717f2c595eb45b52c28e31622dfff which was in my mempool when I wrote the test
-    let script = Builder::new()
+    let script = ScriptPubKey::builder()
         .push_opcode(OP_DUP)
         .push_opcode(OP_HASH160)
         .push_slice(hex!("16e1ae70ff0fa102905d4af297f6912bda6cce19"))
@@ -220,7 +271,7 @@ fn script_builder() {
 
 #[test]
 fn script_builder_with_capacity() {
-    let script = Builder::with_capacity(42);
+    let script = Builder::<Tag>::with_capacity(42);
 
     assert!(script.into_script().capacity() >= 42);
 }
@@ -230,29 +281,30 @@ fn script_generators() {
     let pubkey = "0234e6a79c5359c613762d537e0e19d86c77c1666d8c9ab050f23acd198e97f93e"
         .parse::<PublicKey>()
         .unwrap();
-    assert!(ScriptBuf::new_p2pk(pubkey).is_p2pk());
+    assert!(ScriptPubKeyBuf::new_p2pk(pubkey).is_p2pk());
 
     let pubkey_hash = pubkey.pubkey_hash();
-    assert!(ScriptBuf::new_p2pkh(pubkey_hash).is_p2pkh());
+    assert!(ScriptPubKeyBuf::new_p2pkh(pubkey_hash).is_p2pkh());
 
     let wpubkey_hash = pubkey.wpubkey_hash().unwrap();
-    assert!(ScriptBuf::new_p2wpkh(wpubkey_hash).is_p2wpkh());
+    assert!(ScriptPubKeyBuf::new_p2wpkh(wpubkey_hash).is_p2wpkh());
 
-    let script = Builder::new().push_opcode(OP_NUMEQUAL).push_verify().into_script();
+    let script = RedeemScript::builder().push_opcode(OP_NUMEQUAL).push_verify().into_script();
     let script_hash = script.script_hash().expect("script is less than 520 bytes");
-    let p2sh = ScriptBuf::new_p2sh(script_hash);
+    let p2sh = ScriptPubKeyBuf::new_p2sh(script_hash);
     assert!(p2sh.is_p2sh());
     assert_eq!(script.to_p2sh().unwrap(), p2sh);
 
+    let script = WitnessScript::builder().push_opcode(OP_NUMEQUAL).push_verify().into_script();
     let wscript_hash = script.wscript_hash().expect("script is less than 10,000 bytes");
-    let p2wsh = ScriptBuf::new_p2wsh(wscript_hash);
+    let p2wsh = ScriptPubKeyBuf::new_p2wsh(wscript_hash);
     assert!(p2wsh.is_p2wsh());
     assert_eq!(script.to_p2wsh().unwrap(), p2wsh);
 
     // Test data are taken from the second output of
     // 2ccb3a1f745eb4eefcf29391460250adda5fab78aaddb902d25d3cd97d9d8e61 transaction
     let data = hex!("aa21a9ed20280f53f2d21663cac89e6bd2ad19edbabb048cda08e73ed19e9268d0afea2a");
-    let op_return = ScriptBuf::new_op_return(data);
+    let op_return = ScriptPubKeyBuf::new_op_return(data);
     assert!(op_return.is_op_return());
     assert_eq!(
         op_return.to_hex_string_no_length_prefix(),
@@ -262,6 +314,8 @@ fn script_generators() {
 
 #[test]
 fn script_builder_verify() {
+    type Builder = super::Builder<primitives::script::ScriptPubKeyTag>;
+
     let simple = Builder::new().push_verify().into_script();
     assert_eq!(simple.to_hex_string_no_length_prefix(), "69");
     let simple2 = Builder::from(vec![]).push_verify().into_script();
@@ -299,6 +353,10 @@ fn script_builder_verify() {
     assert_eq!(trick_slice.to_hex_string_no_length_prefix(), "01ae69");
     let trick_slice2 = Builder::from(vec![0x01, 0xae]).push_verify().into_script();
     assert_eq!(trick_slice2.to_hex_string_no_length_prefix(), "01ae69");
+
+    let pushint_then_verify =
+        Builder::new().push_opcode(OP_EQUAL).push_int(5).unwrap().push_verify().into_script();
+    assert_eq!(pushint_then_verify.to_hex_string_no_length_prefix(), "875569");
 }
 
 #[test]
@@ -343,15 +401,17 @@ fn scriptint_round_trip() {
             PushBytes::read_scriptint(
                 <&PushBytes>::try_from(build_scriptint(i).as_slice()).unwrap()
             )
+            .map(i64::from)
         );
         assert_eq!(
             Ok(-i),
             PushBytes::read_scriptint(
                 <&PushBytes>::try_from(build_scriptint(-i).as_slice()).unwrap()
             )
+            .map(i64::from)
         );
-        assert_eq!(Ok(i), read_scriptint_non_minimal(&build_scriptint(i)));
-        assert_eq!(Ok(-i), read_scriptint_non_minimal(&build_scriptint(-i)));
+        assert_eq!(Ok(i), read_scriptint_non_minimal(&build_scriptint(i)).map(i64::from));
+        assert_eq!(Ok(-i), read_scriptint_non_minimal(&build_scriptint(-i)).map(i64::from));
     }
     assert!(PushBytes::read_scriptint(
         <&PushBytes>::try_from(build_scriptint(1 << 31).as_slice()).unwrap()
@@ -377,11 +437,11 @@ fn non_minimal_scriptints() {
     );
     assert_eq!(
         PushBytes::read_scriptint(<[_; 3] as AsRef<PushBytes>>::as_ref(&[0x8f, 0x00, 0x00])),
-        Err(Error::NonMinimalPush)
+        Err(ScriptIntError::NonMinimal)
     );
     assert_eq!(
         PushBytes::read_scriptint(<[_; 2] as AsRef<PushBytes>>::as_ref(&[0x7f, 0x00])),
-        Err(Error::NonMinimalPush)
+        Err(ScriptIntError::NonMinimal)
     );
 
     assert_eq!(read_scriptint_non_minimal(&[0x80, 0x00]), Ok(0x80));
@@ -392,17 +452,18 @@ fn non_minimal_scriptints() {
 
 #[test]
 fn script_hashes() {
-    let script = ScriptBuf::from_hex_no_length_prefix("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap();
+    let script = RedeemScriptBuf::from_hex_no_length_prefix("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap();
     assert_eq!(
         script.script_hash().unwrap().to_string(),
         "8292bcfbef1884f73c813dfe9c82fd7e814291ea"
     );
+    let script = WitnessScriptBuf::from_hex_no_length_prefix("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap();
     assert_eq!(
         script.wscript_hash().unwrap().to_string(),
         "3e1525eb183ad4f9b3c5fa3175bdca2a52e947b135bbb90383bf9f6408e2c324"
     );
     assert_eq!(
-        ScriptBuf::from_hex_no_length_prefix(
+        TapScriptBuf::from_hex_no_length_prefix(
             "20d85a959b0290bf19bb89ed43c916be835475d013da4b362117393e25a48229b8ac"
         )
         .unwrap()
@@ -415,15 +476,15 @@ fn script_hashes() {
 #[test]
 fn provably_unspendable() {
     // p2pk
-    assert!(!ScriptBuf::from_hex_no_length_prefix("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap().is_op_return());
-    assert!(!ScriptBuf::from_hex_no_length_prefix("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap().is_op_return());
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap().is_op_return());
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap().is_op_return());
     // p2pkhash
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac"
     )
     .unwrap()
     .is_op_return());
-    assert!(ScriptBuf::from_hex_no_length_prefix(
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
         "6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87"
     )
     .unwrap()
@@ -432,33 +493,33 @@ fn provably_unspendable() {
 
 #[test]
 fn op_return() {
-    assert!(ScriptBuf::from_hex_no_length_prefix(
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
         "6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87"
     )
     .unwrap()
     .is_op_return());
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac"
     )
     .unwrap()
     .is_op_return());
-    assert!(!ScriptBuf::from_hex_no_length_prefix("").unwrap().is_op_return());
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix("").unwrap().is_op_return());
 }
 
 #[test]
 fn standard_op_return() {
-    assert!(ScriptBuf::from_hex_no_length_prefix(
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
         "6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87"
     )
     .unwrap()
     .is_standard_op_return());
-    assert!(ScriptBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e")
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e")
         .unwrap()
         .is_standard_op_return());
-    assert!(ScriptBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21")
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21")
         .unwrap()
         .is_standard_op_return());
-    assert!(!ScriptBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21524f42")
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21524f42")
         .unwrap()
         .is_standard_op_return());
 }
@@ -468,44 +529,44 @@ fn multisig() {
     // First multisig? 1-of-2
     // In block 164467, txid 60a20bd93aa49ab4b28d514ec10b06e1829ce6818ec06cd3aabd013ebcdc4bb1
     assert!(
-        ScriptBuf::from_hex_no_length_prefix("514104cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4410461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af52ae")
+        ScriptPubKeyBuf::from_hex_no_length_prefix("514104cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4410461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af52ae")
             .unwrap()
             .is_multisig()
     );
     // 2-of-2
     assert!(
-        ScriptBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
+        ScriptPubKeyBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
             .unwrap()
             .is_multisig()
     );
 
     // Extra opcode after OP_CHECKMULTISIG
     assert!(
-        !ScriptBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae52")
+        !ScriptPubKeyBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae52")
             .unwrap()
             .is_multisig()
     );
     // Required sigs > num pubkeys
     assert!(
-        !ScriptBuf::from_hex_no_length_prefix("5321021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
+        !ScriptPubKeyBuf::from_hex_no_length_prefix("5321021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
             .unwrap()
             .is_multisig()
     );
     // Num pubkeys != pushnum
     assert!(
-        !ScriptBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f453ae")
+        !ScriptPubKeyBuf::from_hex_no_length_prefix("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f453ae")
             .unwrap()
             .is_multisig()
     );
 
     // Taproot hash from another test
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "20d85a959b0290bf19bb89ed43c916be835475d013da4b362117393e25a48229b8ac"
     )
     .unwrap()
     .is_multisig());
     // OP_RETURN from another test
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87"
     )
     .unwrap()
@@ -569,33 +630,35 @@ fn script_buf_collect() {
 }
 
 #[test]
-fn script_p2sh_p2p2k_template() {
+fn script_p2sh_p2pkh_template() {
     // random outputs I picked out of the mempool
-    assert!(ScriptBuf::from_hex_no_length_prefix(
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
         "76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac"
     )
     .unwrap()
     .is_p2pkh());
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac"
     )
     .unwrap()
     .is_p2sh());
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ad"
     )
     .unwrap()
     .is_p2pkh());
-    assert!(!ScriptBuf::from_hex_no_length_prefix("").unwrap().is_p2pkh());
-    assert!(ScriptBuf::from_hex_no_length_prefix("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
-        .unwrap()
-        .is_p2sh());
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix("").unwrap().is_p2pkh());
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
+        "a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87"
+    )
+    .unwrap()
+    .is_p2sh());
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87"
     )
     .unwrap()
     .is_p2pkh());
-    assert!(!ScriptBuf::from_hex_no_length_prefix(
+    assert!(!ScriptPubKeyBuf::from_hex_no_length_prefix(
         "a314acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87"
     )
     .unwrap()
@@ -604,20 +667,20 @@ fn script_p2sh_p2p2k_template() {
 
 #[test]
 fn script_p2pk() {
-    assert!(ScriptBuf::from_hex_no_length_prefix(
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix(
         "21021aeaf2f8638a129a3156fbe7e5ef635226b0bafd495ff03afe2c843d7e3a4b51ac"
     )
     .unwrap()
     .is_p2pk());
-    assert!(ScriptBuf::from_hex_no_length_prefix("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac").unwrap().is_p2pk());
+    assert!(ScriptPubKeyBuf::from_hex_no_length_prefix("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac").unwrap().is_p2pk());
 }
 
 #[test]
 fn p2sh_p2wsh_conversion() {
     // Test vectors taken from Core tests/data/script_tests.json
     // bare p2wsh
-    let witness_script = ScriptBuf::from_hex_no_length_prefix("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
-    let expected_without = ScriptBuf::from_hex_no_length_prefix(
+    let witness_script = WitnessScriptBuf::from_hex_no_length_prefix("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
+    let expected_without = ScriptPubKeyBuf::from_hex_no_length_prefix(
         "0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64",
     )
     .unwrap();
@@ -625,23 +688,25 @@ fn p2sh_p2wsh_conversion() {
     assert_eq!(witness_script.to_p2wsh().unwrap(), expected_without);
 
     // p2sh
-    let redeem_script = ScriptBuf::from_hex_no_length_prefix("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8").unwrap();
-    let expected_p2shout =
-        ScriptBuf::from_hex_no_length_prefix("a91491b24bf9f5288532960ac687abb035127b1d28a587")
-            .unwrap();
+    let redeem_script = RedeemScriptBuf::from_hex_no_length_prefix("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8").unwrap();
+    let expected_p2shout = ScriptPubKeyBuf::from_hex_no_length_prefix(
+        "a91491b24bf9f5288532960ac687abb035127b1d28a587",
+    )
+    .unwrap();
     assert!(redeem_script.to_p2sh().unwrap().is_p2sh());
     assert_eq!(redeem_script.to_p2sh().unwrap(), expected_p2shout);
 
     // p2sh-p2wsh
-    let witness_script = ScriptBuf::from_hex_no_length_prefix("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
-    let expected_without = ScriptBuf::from_hex_no_length_prefix(
+    let witness_script = WitnessScriptBuf::from_hex_no_length_prefix("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
+    let expected_without = ScriptPubKeyBuf::from_hex_no_length_prefix(
         "0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64",
     )
     .unwrap();
-    let expected_out =
-        ScriptBuf::from_hex_no_length_prefix("a914f386c2ba255cc56d20cfa6ea8b062f8b5994551887")
-            .unwrap();
-    assert!(witness_script.to_p2sh().unwrap().is_p2sh());
+    let expected_out = ScriptPubKeyBuf::from_hex_no_length_prefix(
+        "a914f386c2ba255cc56d20cfa6ea8b062f8b5994551887",
+    )
+    .unwrap();
+    // assert!(witness_script.to_p2sh().unwrap().is_p2sh()); // This is meaningless and no longer compiles
     assert_eq!(witness_script.to_p2wsh().unwrap(), expected_without);
     assert_eq!(witness_script.to_p2wsh().unwrap().to_p2sh().unwrap(), expected_out);
 }
@@ -689,7 +754,10 @@ fn iterator() {
 
     assert_eq!(
         v_min,
-        vec![(0, Instruction::PushBytes([105].as_ref())), (2, Instruction::Op(opcodes::OP_NOP3))]
+        vec![
+            (0, Instruction::PushBytes([105].as_ref())),
+            (2, Instruction::Op(opcodes::all::OP_NOP3))
+        ]
     );
 
     assert_eq!(v_nonmin.unwrap_err(), Error::NonMinimalPush);
@@ -698,7 +766,7 @@ fn iterator() {
         v_nonmin_alt,
         vec![
             (0, Instruction::PushBytes([105, 0].as_ref())),
-            (3, Instruction::Op(opcodes::OP_NOP3))
+            (3, Instruction::Op(opcodes::all::OP_NOP3))
         ]
     );
 
@@ -714,7 +782,7 @@ fn iterator() {
 
 #[test]
 fn script_ord() {
-    let script_1 = Builder::new().push_slice([1, 2, 3, 4]).into_script();
+    let script_1 = Builder::<Tag>::new().push_slice([1, 2, 3, 4]).into_script();
     let script_2 = Builder::new().push_int_unchecked(10).into_script();
     let script_3 = Builder::new().push_int_unchecked(15).into_script();
     let script_4 = Builder::new().push_opcode(OP_RETURN).into_script();
@@ -734,11 +802,11 @@ fn script_ord() {
 #[test]
 #[cfg(feature = "bitcoinconsensus")]
 fn bitcoinconsensus() {
-    use crate::consensus_validation::ScriptExt as _;
+    use crate::consensus_validation::ScriptPubKeyExt as _;
 
     // a random SegWit transaction from the blockchain using native SegWit
     let spent_bytes = hex!("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d");
-    let spent = Script::from_bytes(&spent_bytes);
+    let spent = ScriptPubKey::from_bytes(&spent_bytes);
     let spending = hex!("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000");
     spent.verify(0, Amount::from_sat_u32(18393430), &spending).unwrap();
 }
@@ -751,7 +819,7 @@ fn default_dust_value() {
     assert!(script_p2wpkh.is_p2wpkh());
     assert_eq!(script_p2wpkh.minimal_non_dust(), Amount::from_sat_u32(294));
     assert_eq!(
-        script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
+        script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb(6)),
         Some(Amount::from_sat_u32(588))
     );
 
@@ -765,7 +833,7 @@ fn default_dust_value() {
     assert!(script_p2pkh.is_p2pkh());
     assert_eq!(script_p2pkh.minimal_non_dust(), Amount::from_sat_u32(546));
     assert_eq!(
-        script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
+        script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb(6)),
         Some(Amount::from_sat_u32(1092))
     );
 }
@@ -773,7 +841,7 @@ fn default_dust_value() {
 #[test]
 fn script_get_sigop_count() {
     assert_eq!(
-        Builder::new()
+        Script::builder()
             .push_opcode(OP_DUP)
             .push_opcode(OP_HASH160)
             .push_slice([42; 20])
@@ -783,7 +851,7 @@ fn script_get_sigop_count() {
         0
     );
     assert_eq!(
-        Builder::new()
+        Script::builder()
             .push_opcode(OP_DUP)
             .push_opcode(OP_HASH160)
             .push_slice([42; 20])
@@ -794,40 +862,40 @@ fn script_get_sigop_count() {
         1
     );
     assert_eq!(
-        Builder::new()
+        Script::builder()
             .push_opcode(OP_DUP)
             .push_opcode(OP_HASH160)
             .push_slice([42; 20])
             .push_opcode(OP_EQUALVERIFY)
             .push_opcode(OP_CHECKSIGVERIFY)
-            .push_opcode(OP_PUSHNUM_1)
+            .push_opcode(OP_1)
             .into_script()
             .count_sigops(),
         1
     );
-    let multi = Builder::new()
-        .push_opcode(OP_PUSHNUM_1)
+    let multi = Script::builder()
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
-        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_3)
         .push_opcode(OP_CHECKMULTISIG)
         .into_script();
     assert_eq!(multi.count_sigops(), 3);
     assert_eq!(multi.count_sigops_legacy(), 20);
-    let multi_verify = Builder::new()
-        .push_opcode(OP_PUSHNUM_1)
+    let multi_verify = Script::builder()
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
-        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_3)
         .push_opcode(OP_CHECKMULTISIGVERIFY)
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .into_script();
     assert_eq!(multi_verify.count_sigops(), 3);
     assert_eq!(multi_verify.count_sigops_legacy(), 20);
-    let multi_nopushnum_pushdata = Builder::new()
-        .push_opcode(OP_PUSHNUM_1)
+    let multi_nopushnum_pushdata = Script::builder()
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
@@ -835,8 +903,8 @@ fn script_get_sigop_count() {
         .into_script();
     assert_eq!(multi_nopushnum_pushdata.count_sigops(), 20);
     assert_eq!(multi_nopushnum_pushdata.count_sigops_legacy(), 20);
-    let multi_nopushnum_op = Builder::new()
-        .push_opcode(OP_PUSHNUM_1)
+    let multi_nopushnum_op = Script::builder()
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_opcode(OP_DROP)
@@ -959,10 +1027,10 @@ fn instruction_script_num_parse() {
     ];
     let ops = [
         (Instruction::Op(opcodes::all::OP_PUSHDATA4), None),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_NEG1), Some(-1)),
+        (Instruction::Op(opcodes::all::OP_1NEGATE), Some(-1)),
         (Instruction::Op(opcodes::all::OP_RESERVED), None),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_1), Some(1)),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_16), Some(16)),
+        (Instruction::Op(opcodes::all::OP_1), Some(1)),
+        (Instruction::Op(opcodes::all::OP_16), Some(16)),
         (Instruction::Op(opcodes::all::OP_NOP), None),
     ];
     for (input, expected) in &push_bytes {
@@ -983,5 +1051,27 @@ fn instruction_script_num_parse() {
 #[test]
 fn script_push_int_overflow() {
     // Only errors if `data == i32::MIN` (CScriptNum cannot have value -2^31).
-    assert_eq!(Builder::new().push_int(i32::MIN), Err(Error::NumericOverflow));
+    assert_eq!(Builder::<Tag>::new().push_int(i32::MIN), Err(Error::NumericOverflow));
+}
+
+#[test]
+fn shortest_witness_program() {
+    let bytes = [0x00; 2]; // Arbitrary bytes, witprog must be between 2 and 40.
+    let version = WitnessVersion::V15; // Arbitrary version number, intentionally not 0 or 1.
+
+    let p = WitnessProgram::new(version, &bytes).expect("failed to create witness program");
+    let script = ScriptPubKeyBuf::new_witness_program(&p);
+
+    assert_eq!(script.witness_version(), Some(version));
+}
+
+#[test]
+fn longest_witness_program() {
+    let bytes = [0x00; 40]; // Arbitrary bytes, witprog must be between 2 and 40.
+    let version = WitnessVersion::V16; // Arbitrary version number, intentionally not 0 or 1.
+
+    let p = WitnessProgram::new(version, &bytes).expect("failed to create witness program");
+    let script = ScriptPubKeyBuf::new_witness_program(&p);
+
+    assert_eq!(script.witness_version(), Some(version));
 }
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 7ef28b8466..4cee8811b3 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -1,22 +1,21 @@
-//! The segregated witness program as defined by [BIP141].
+//! The segregated witness program as defined by [BIP-0141].
 //!
-//! > A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte push
+//! > A scriptPubKey (or redeemScript as defined in BIP-0016/P2SH) that consists of a 1-byte push
 //! > opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new special
 //! > meaning. The value of the first push is called the "version byte". The following byte
 //! > vector pushed is called the "witness program".
 //!
-//! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
+//! [BIP-0141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
 
 use core::convert::Infallible;
 use core::fmt;
 
 use internals::array_vec::ArrayVec;
-use secp256k1::{Secp256k1, Verification};
 
 use super::witness_version::WitnessVersion;
-use super::{PushBytes, Script, WScriptHash, WitnessScriptSizeError};
+use super::{PushBytes, WScriptHash, WitnessScript, WitnessScriptSizeError};
 use crate::crypto::key::{CompressedPublicKey, TapTweak, TweakedPublicKey, UntweakedPublicKey};
-use crate::script::ScriptExt as _;
+use crate::script::WitnessScriptExt as _;
 use crate::taproot::TapNodeHash;
 
 /// The minimum byte size of a segregated witness program.
@@ -44,77 +43,72 @@ pub struct WitnessProgram {
 impl WitnessProgram {
     /// Constructs a new witness program, copying the content from the given byte slice.
     pub fn new(version: WitnessVersion, bytes: &[u8]) -> Result<Self, Error> {
-        use Error::*;
-
         let program_len = bytes.len();
         if program_len < MIN_SIZE || program_len > MAX_SIZE {
-            return Err(InvalidLength(program_len));
+            return Err(Error::InvalidLength(program_len));
         }
 
         // Specific SegWit v0 check. These addresses can never spend funds sent to them.
         if version == WitnessVersion::V0 && (program_len != 20 && program_len != 32) {
-            return Err(InvalidSegwitV0Length(program_len));
+            return Err(Error::InvalidSegwitV0Length(program_len));
         }
 
         let program = ArrayVec::from_slice(bytes);
-        Ok(WitnessProgram { version, program })
+        Ok(Self { version, program })
     }
 
     /// Constructs a new [`WitnessProgram`] from a 20 byte pubkey hash.
     fn new_p2wpkh(program: [u8; 20]) -> Self {
-        WitnessProgram { version: WitnessVersion::V0, program: ArrayVec::from_slice(&program) }
+        Self { version: WitnessVersion::V0, program: ArrayVec::from_slice(&program) }
     }
 
     /// Constructs a new [`WitnessProgram`] from a 32 byte script hash.
     fn new_p2wsh(program: [u8; 32]) -> Self {
-        WitnessProgram { version: WitnessVersion::V0, program: ArrayVec::from_slice(&program) }
+        Self { version: WitnessVersion::V0, program: ArrayVec::from_slice(&program) }
     }
 
     /// Constructs a new [`WitnessProgram`] from a 32 byte serialized Taproot x-only pubkey.
     fn new_p2tr(program: [u8; 32]) -> Self {
-        WitnessProgram { version: WitnessVersion::V1, program: ArrayVec::from_slice(&program) }
+        Self { version: WitnessVersion::V1, program: ArrayVec::from_slice(&program) }
     }
 
     /// Constructs a new [`WitnessProgram`] from `pk` for a P2WPKH output.
     pub fn p2wpkh(pk: CompressedPublicKey) -> Self {
         let hash = pk.wpubkey_hash();
-        WitnessProgram::new_p2wpkh(hash.to_byte_array())
+        Self::new_p2wpkh(hash.to_byte_array())
     }
 
     /// Constructs a new [`WitnessProgram`] from `script` for a P2WSH output.
-    pub fn p2wsh(script: &Script) -> Result<Self, WitnessScriptSizeError> {
+    pub fn p2wsh(script: &WitnessScript) -> Result<Self, WitnessScriptSizeError> {
         script.wscript_hash().map(Self::p2wsh_from_hash)
     }
 
     /// Constructs a new [`WitnessProgram`] from `script` for a P2WSH output.
-    pub fn p2wsh_from_hash(hash: WScriptHash) -> Self {
-        WitnessProgram::new_p2wsh(hash.to_byte_array())
-    }
+    pub fn p2wsh_from_hash(hash: WScriptHash) -> Self { Self::new_p2wsh(hash.to_byte_array()) }
 
     /// Constructs a new [`WitnessProgram`] from an untweaked key for a P2TR output.
     ///
-    /// This function applies BIP341 key-tweaking to the untweaked
+    /// This function applies BIP-0341 key-tweaking to the untweaked
     /// key using the merkle root, if it's present.
-    pub fn p2tr<C: Verification, K: Into<UntweakedPublicKey>>(
-        secp: &Secp256k1<C>,
+    pub fn p2tr<K: Into<UntweakedPublicKey>>(
         internal_key: K,
         merkle_root: Option<TapNodeHash>,
     ) -> Self {
         let internal_key = internal_key.into();
-        let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);
+        let (output_key, _parity) = internal_key.tap_tweak(merkle_root);
         let pubkey = output_key.as_x_only_public_key().serialize();
-        WitnessProgram::new_p2tr(pubkey)
+        Self::new_p2tr(pubkey)
     }
 
     /// Constructs a new [`WitnessProgram`] from a tweaked key for a P2TR output.
     pub fn p2tr_tweaked(output_key: TweakedPublicKey) -> Self {
         let pubkey = output_key.as_x_only_public_key().serialize();
-        WitnessProgram::new_p2tr(pubkey)
+        Self::new_p2tr(pubkey)
     }
 
     /// Constructs a new [`WitnessProgram`] for a P2A output.
     pub const fn p2a() -> Self {
-        WitnessProgram { version: WitnessVersion::V1, program: ArrayVec::from_slice(&P2A_PROGRAM) }
+        Self { version: WitnessVersion::V1, program: ArrayVec::from_slice(&P2A_PROGRAM) }
     }
 
     /// Returns the witness program version.
@@ -133,7 +127,7 @@ impl WitnessProgram {
         self.version == WitnessVersion::V0 && self.program.len() == 20
     }
 
-    /// Returns true if this witness program is for a P2WPSH output.
+    /// Returns true if this witness program is for a P2WSH output.
     pub fn is_p2wsh(&self) -> bool {
         self.version == WitnessVersion::V0 && self.program.len() == 32
     }
@@ -163,12 +157,10 @@ impl From<Infallible> for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Error::*;
-
-        match *self {
-            InvalidLength(len) =>
+        match self {
+            Self::InvalidLength(len) =>
                 write!(f, "witness program must be between 2 and 40 bytes: length={}", len),
-            InvalidSegwitV0Length(len) =>
+            Self::InvalidSegwitV0Length(len) =>
                 write!(f, "a v0 witness program must be either 20 or 32 bytes: length={}", len),
         }
     }
@@ -177,10 +169,8 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Error::*;
-
-        match *self {
-            InvalidLength(_) | InvalidSegwitV0Length(_) => None,
+        match self {
+            Self::InvalidLength(_) | Self::InvalidSegwitV0Length(_) => None,
         }
     }
 }
diff --git a/bitcoin/src/blockdata/script/witness_version.rs b/bitcoin/src/blockdata/script/witness_version.rs
index 0ede306411..bc09c68c47 100644
--- a/bitcoin/src/blockdata/script/witness_version.rs
+++ b/bitcoin/src/blockdata/script/witness_version.rs
@@ -1,21 +1,21 @@
-//! The segregated witness version byte as defined by [BIP141].
+//! The segregated witness version byte as defined by [BIP-0141].
 //!
-//! > A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte push
+//! > A scriptPubKey (or redeemScript as defined in BIP-0016/P2SH) that consists of a 1-byte push
 //! > opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new special
 //! > meaning. The value of the first push is called the "version byte". The following byte
 //! > vector pushed is called the "witness program".
 //!
-//! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
+//! [BIP-0141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
 
 use core::convert::Infallible;
 use core::fmt;
 use core::str::FromStr;
 
 use internals::write_err;
-use units::parse::{self, ParseIntError};
 
 use crate::opcodes::all::*;
 use crate::opcodes::Opcode;
+use crate::parse_int::{self, ParseIntError};
 use crate::script::Instruction;
 
 /// Version of the segregated witness program.
@@ -82,8 +82,8 @@ impl FromStr for WitnessVersion {
     type Err = FromStrError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let version: u8 = parse::int_from_str(s)?;
-        Ok(WitnessVersion::try_from(version)?)
+        let version: u8 = parse_int::int_from_str(s)?;
+        Ok(Self::try_from(version)?)
     }
 }
 
@@ -121,9 +121,9 @@ impl TryFrom<Opcode> for WitnessVersion {
 
     fn try_from(opcode: Opcode) -> Result<Self, Self::Error> {
         match opcode.to_u8() {
-            0 => Ok(WitnessVersion::V0),
-            version if version >= OP_PUSHNUM_1.to_u8() && version <= OP_PUSHNUM_16.to_u8() =>
-                WitnessVersion::try_from(version - OP_PUSHNUM_1.to_u8() + 1),
+            0 => Ok(Self::V0),
+            version if version >= OP_1.to_u8() && version <= OP_16.to_u8() =>
+                Self::try_from(version - OP_1.to_u8() + 1),
             invalid => Err(TryFromError { invalid }),
         }
     }
@@ -134,18 +134,18 @@ impl TryFrom<Instruction<'_>> for WitnessVersion {
 
     fn try_from(instruction: Instruction) -> Result<Self, Self::Error> {
         match instruction {
-            Instruction::Op(op) => Ok(WitnessVersion::try_from(op)?),
-            Instruction::PushBytes(bytes) if bytes.is_empty() => Ok(WitnessVersion::V0),
+            Instruction::Op(op) => Ok(Self::try_from(op)?),
+            Instruction::PushBytes(bytes) if bytes.is_empty() => Ok(Self::V0),
             Instruction::PushBytes(_) => Err(TryFromInstructionError::DataPush),
         }
     }
 }
 
 impl From<WitnessVersion> for Opcode {
-    fn from(version: WitnessVersion) -> Opcode {
+    fn from(version: WitnessVersion) -> Self {
         match version {
             WitnessVersion::V0 => OP_PUSHBYTES_0,
-            no => Opcode::from(OP_PUSHNUM_1.to_u8() + no.to_num() - 1),
+            no => Self::from(OP_1.to_u8() + no.to_num() - 1),
         }
     }
 }
@@ -166,11 +166,9 @@ impl From<Infallible> for FromStrError {
 
 impl fmt::Display for FromStrError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use FromStrError::*;
-
-        match *self {
-            Unparsable(ref e) => write_err!(f, "integer parse error"; e),
-            Invalid(ref e) => write_err!(f, "invalid version number"; e),
+        match self {
+            Self::Unparsable(ref e) => write_err!(f, "integer parse error"; e),
+            Self::Invalid(ref e) => write_err!(f, "invalid version number"; e),
         }
     }
 }
@@ -178,11 +176,9 @@ impl fmt::Display for FromStrError {
 #[cfg(feature = "std")]
 impl std::error::Error for FromStrError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use FromStrError::*;
-
-        match *self {
-            Unparsable(ref e) => Some(e),
-            Invalid(ref e) => Some(e),
+        match self {
+            Self::Unparsable(ref e) => Some(e),
+            Self::Invalid(ref e) => Some(e),
         }
     }
 }
@@ -199,7 +195,7 @@ impl From<TryFromError> for FromStrError {
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum TryFromInstructionError {
-    /// Cannot not convert OP to a witness version.
+    /// Cannot convert OP to a witness version.
     TryFrom(TryFromError),
     /// Cannot create a witness version from non-zero data push.
     DataPush,
@@ -211,11 +207,9 @@ impl From<Infallible> for TryFromInstructionError {
 
 impl fmt::Display for TryFromInstructionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use TryFromInstructionError::*;
-
-        match *self {
-            TryFrom(ref e) => write_err!(f, "opcode is not a valid witness version"; e),
-            DataPush => write!(f, "non-zero data push opcode is not a valid witness version"),
+        match self {
+            Self::TryFrom(ref e) => write_err!(f, "opcode is not a valid witness version"; e),
+            Self::DataPush => write!(f, "non-zero data push opcode is not a valid witness version"),
         }
     }
 }
@@ -223,11 +217,9 @@ impl fmt::Display for TryFromInstructionError {
 #[cfg(feature = "std")]
 impl std::error::Error for TryFromInstructionError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use TryFromInstructionError::*;
-
-        match *self {
-            TryFrom(ref e) => Some(e),
-            DataPush => None,
+        match self {
+            Self::TryFrom(ref e) => Some(e),
+            Self::DataPush => None,
         }
     }
 }
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 9cc1c59399..61bd5513c8 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -12,31 +12,53 @@
 
 use core::fmt;
 
-use hashes::sha256d;
-use internals::{compact_size, write_err, ToU64};
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use internals::{compact_size, const_casts, write_err, ToU64};
 use io::{BufRead, Write};
-use primitives::Sequence;
-use units::NumOpResult;
 
 use super::Weight;
 use crate::consensus::{self, encode, Decodable, Encodable};
-use crate::internal_macros::{impl_consensus_encoding, impl_hashencode};
 use crate::locktime::absolute::{self, Height, MedianTimePast};
 use crate::prelude::{Borrow, Vec};
-use crate::script::{Script, ScriptBuf, ScriptExt as _, ScriptExtPriv as _};
+use crate::script::{
+    RedeemScript, ScriptExt as _, ScriptExtPriv as _, ScriptPubKey, ScriptPubKeyBuf,
+    ScriptPubKeyExt as _, WitnessScript,
+};
 #[cfg(doc)]
 use crate::sighash::{EcdsaSighashType, TapSighashType};
 use crate::witness::Witness;
-use crate::{Amount, FeeRate, SignedAmount};
+use crate::{internal_macros, Amount, FeeRate, Sequence, SignedAmount};
 
 #[rustfmt::skip]            // Keep public re-exports separate.
 #[doc(inline)]
-pub use primitives::transaction::{OutPoint, ParseOutPointError, Transaction, Txid, Wtxid, Version, TxIn, TxOut};
+pub use primitives::transaction::{OutPoint, ParseOutPointError, Transaction, Ntxid, Txid, Wtxid, Version, TxIn, TxOut};
 
-impl_hashencode!(Txid);
-impl_hashencode!(Wtxid);
+impl Encodable for Txid {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for Txid {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(r)?))
+    }
+}
+
+impl Encodable for Wtxid {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for Wtxid {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(r)?))
+    }
+}
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Txid`] type.
     pub trait TxidExt impl for Txid {
         /// The "all zeros" TXID.
@@ -45,7 +67,7 @@ crate::internal_macros::define_extension_trait! {
     }
 }
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Wtxid`] type.
     pub trait WtxidExt impl for Wtxid {
         /// The "all zeros" wTXID.
@@ -61,12 +83,12 @@ impl TxIdentifier for Txid {}
 impl TxIdentifier for Wtxid {}
 
 // Duplicated in `primitives`.
-/// The marker MUST be a 1-byte zero value: 0x00. (BIP-141)
+/// The marker MUST be a 1-byte zero value: 0x00. (BIP-0141)
 const SEGWIT_MARKER: u8 = 0x00;
-/// The flag MUST be a 1-byte non-zero value. Currently, 0x01 MUST be used. (BIP-141)
+/// The flag MUST be a 1-byte non-zero value. Currently, 0x01 MUST be used. (BIP-0141)
 const SEGWIT_FLAG: u8 = 0x01;
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`OutPoint`] type.
     pub trait OutPointExt impl for OutPoint {
         /// Constructs a new [`OutPoint`].
@@ -89,7 +111,7 @@ crate::internal_macros::define_extension_trait! {
 const TX_IN_BASE_WEIGHT: Weight =
     Weight::from_vb_unchecked(OutPoint::SIZE as u64 + Sequence::SIZE as u64);
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`TxIn`] type.
     pub trait TxInExt impl for TxIn {
         /// Returns true if this input enables the [`absolute::LockTime`] (aka `nLockTime`) of its
@@ -100,7 +122,7 @@ crate::internal_macros::define_extension_trait! {
         ///  ignored. If this returns false and OP_CHECKLOCKTIMEVERIFY is used in the redeem script with
         ///  this input then the script execution will fail [BIP-0065].
         ///
-        /// [BIP-65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+        /// [BIP-0065](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
         fn enables_lock_time(&self) -> bool { self.sequence != Sequence::MAX }
 
         /// The weight of the TxIn when it's included in a legacy transaction (i.e., a transaction
@@ -111,30 +133,42 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// Keep in mind that when adding a TxIn to a transaction, the total weight of the transaction
         /// might increase more than `TxIn::legacy_weight`. This happens when the new input added causes
-        /// the input length `VarInt` to increase its encoding length.
+        /// the input length `CompactSize` to increase its encoding length.
+        ///
+        /// # Panics
+        ///
+        /// If the conversion overflows.
         fn legacy_weight(&self) -> Weight {
-            Weight::from_non_witness_data_size(self.base_size().to_u64())
+            Weight::from_vb(self.base_size().to_u64()).unwrap()
         }
 
         /// The weight of the TxIn when it's included in a SegWit transaction (i.e., a transaction
         /// having at least one SegWit input).
         ///
-        /// This always takes into account the witness, even when empty, in which
-        /// case 1WU for the witness length varint (`00`) is included.
+        /// This always takes into account the witness, even when empty (in which
+        /// case 1WU for the witness length `00` is included).
         ///
         /// Keep in mind that when adding a TxIn to a transaction, the total weight of the transaction
         /// might increase more than `TxIn::segwit_weight`. This happens when:
-        /// - the new input added causes the input length `VarInt` to increase its encoding length
+        /// - the new input added causes the input length `CompactSize` to increase its encoding length
         /// - the new input is the first segwit input added - this will add an additional 2WU to the
         ///   transaction weight to take into account the SegWit marker
+        ///
+        /// # Panics
+        ///
+        /// If the conversion overflows.
         fn segwit_weight(&self) -> Weight {
-            Weight::from_non_witness_data_size(self.base_size().to_u64())
-                + Weight::from_witness_data_size(self.witness.size().to_u64())
+            Weight::from_vb(self.base_size().to_u64())
+            .and_then(|w| w.checked_add(Weight::from_wu(self.witness.size().to_u64()))).unwrap()
         }
 
         /// Returns the base size of this input.
         ///
         /// Base size excludes the witness data (see [`Self::total_size`]).
+        ///
+        /// # Panics
+        ///
+        /// If the size calculation overflows.
         fn base_size(&self) -> usize {
             let mut size = OutPoint::SIZE;
 
@@ -147,18 +181,22 @@ crate::internal_macros::define_extension_trait! {
         /// Returns the total number of bytes that this input contributes to a transaction.
         ///
         /// Total size includes the witness data (for base size see [`Self::base_size`]).
+        ///
+        /// # Panics
+        ///
+        /// If the size calculation overflows.
         fn total_size(&self) -> usize { self.base_size() + self.witness.size() }
     }
 }
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`TxOut`] type.
     pub trait TxOutExt impl for TxOut {
         /// The weight of this output.
         ///
         /// Keep in mind that when adding a [`TxOut`] to a [`Transaction`] the total weight of the
         /// transaction might increase more than `TxOut::weight`. This happens when the new output added
-        /// causes the output length `VarInt` to increase its encoding length.
+        /// causes the output length `CompactSize` to increase its encoding length.
         ///
         /// # Panics
         ///
@@ -184,11 +222,11 @@ crate::internal_macros::define_extension_trait! {
         /// To use a custom value, use [`minimal_non_dust_custom`].
         ///
         /// [`minimal_non_dust_custom`]: TxOut::minimal_non_dust_custom
-        fn minimal_non_dust(script_pubkey: ScriptBuf) -> TxOut {
-            TxOut { value: script_pubkey.minimal_non_dust(), script_pubkey }
+        fn minimal_non_dust(script_pubkey: ScriptPubKeyBuf) -> Self {
+            TxOut { amount: script_pubkey.minimal_non_dust(), script_pubkey }
         }
 
-        /// Constructs a new `TxOut` with given script and the smallest possible `value` that is **not** dust
+        /// Constructs a new `TxOut` with given script and the smallest possible `amount` that is **not** dust
         /// per current Core policy.
         ///
         /// Dust depends on the -dustrelayfee value of the Bitcoin Core node you are broadcasting to.
@@ -199,14 +237,17 @@ crate::internal_macros::define_extension_trait! {
         /// To use the default Bitcoin Core value, use [`minimal_non_dust`].
         ///
         /// [`minimal_non_dust`]: TxOut::minimal_non_dust
-        fn minimal_non_dust_custom(script_pubkey: ScriptBuf, dust_relay_fee: FeeRate) -> Option<TxOut> {
-            Some(TxOut { value: script_pubkey.minimal_non_dust_custom(dust_relay_fee)?, script_pubkey })
+        fn minimal_non_dust_custom(script_pubkey: ScriptPubKeyBuf, dust_relay_fee: FeeRate) -> Option<Self>
+        where
+            Self: Sized
+        {
+            Some(TxOut { amount: script_pubkey.minimal_non_dust_custom(dust_relay_fee)?, script_pubkey })
         }
     }
 }
 
 /// Returns the total number of bytes that this script pubkey would contribute to a transaction.
-fn size_from_script_pubkey(script_pubkey: &Script) -> usize {
+fn size_from_script_pubkey(script_pubkey: &ScriptPubKey) -> usize {
     let len = script_pubkey.len();
     Amount::SIZE + compact_size::encoded_size(len) + len
 }
@@ -215,7 +256,7 @@ fn size_from_script_pubkey(script_pubkey: &Script) -> usize {
 pub trait TransactionExt: sealed::Sealed {
     /// Computes a "normalized TXID" which does not include any signatures.
     #[deprecated(since = "0.31.0", note = "use `compute_ntxid()` instead")]
-    fn ntxid(&self) -> sha256d::Hash;
+    fn ntxid(&self) -> Ntxid;
 
     /// Computes the [`Txid`].
     #[deprecated(since = "0.31.0", note = "use `compute_txid()` instead")]
@@ -225,7 +266,7 @@ pub trait TransactionExt: sealed::Sealed {
     #[deprecated(since = "0.31.0", note = "use `compute_wtxid()` instead")]
     fn wtxid(&self) -> Wtxid;
 
-    /// Returns the weight of this transaction, as defined by BIP-141.
+    /// Returns the weight of this transaction, as defined by BIP-0141.
     ///
     /// > Transaction weight is defined as Base transaction size * 3 + Total transaction size (ie.
     /// > the same method as calculating Block weight from Base size and Total size).
@@ -237,7 +278,7 @@ pub trait TransactionExt: sealed::Sealed {
     /// For transactions with no inputs, this function will return a value 2 less than the actual
     /// weight of the serialized transaction. The reason is that zero-input transactions, post-SegWit,
     /// cannot be unambiguously serialized; we make a choice that adds two extra bytes. For more
-    /// details see [BIP 141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    /// details see [BIP-0141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
     /// which uses a "input count" of `0x00` as a `marker` for a SegWit-encoded transaction.
     ///
     /// If you need to use 0-input transactions, we strongly recommend you do so using the PSBT
@@ -248,37 +289,36 @@ pub trait TransactionExt: sealed::Sealed {
     /// Returns the base transaction size.
     ///
     /// > Base transaction size is the size of the transaction serialised with the witness data stripped.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
     fn base_size(&self) -> usize;
 
     /// Returns the total transaction size.
     ///
-    /// > Total transaction size is the transaction size in bytes serialized as described in BIP144,
+    /// > Total transaction size is the transaction size in bytes serialized as described in BIP-0144,
     /// > including base data and witness data.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
     fn total_size(&self) -> usize;
 
     /// Returns the "virtual size" (vsize) of this transaction.
     ///
-    /// Will be `ceil(weight / 4.0)`. Note this implements the virtual size as per [`BIP141`], which
+    /// Will be `ceil(weight / 4.0)`. Note this implements the virtual size as per [`BIP-0141`], which
     /// is different to what is implemented in Bitcoin Core. The computation should be the same for
     /// any remotely sane transaction, and a standardness-rule-correct version is available in the
     /// [`policy`] module.
     ///
     /// > Virtual transaction size is defined as Transaction weight / 4 (rounded up to the next integer).
     ///
-    /// [`BIP141`]: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki
+    /// [`BIP-0141`]: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki
     /// [`policy`]: crate::policy
     fn vsize(&self) -> usize;
 
-    /// Checks if this is a coinbase transaction.
-    ///
-    /// The first transaction in the block distributes the mining reward and is called the coinbase
-    /// transaction. It is impossible to check if the transaction is first in the block, so this
-    /// function checks the structure of the transaction instead - the previous output must be
-    /// all-zeros (creates satoshis "out of thin air").
-    #[doc(alias = "is_coin_base")] // method previously had this name
-    fn is_coinbase(&self) -> bool;
-
-    /// Returns `true` if the transaction itself opted in to be BIP-125-replaceable (RBF).
+    /// Returns `true` if the transaction itself opted in to be BIP-0125-replaceable (RBF).
     ///
     /// # Warning
     ///
@@ -298,9 +338,9 @@ pub trait TransactionExt: sealed::Sealed {
     /// transaction from being mined immediately.
     fn is_absolute_timelock_satisfied(&self, height: Height, time: MedianTimePast) -> bool;
 
-    /// Returns `true` if this transactions nLockTime is enabled ([BIP-65]).
+    /// Returns `true` if this transactions nLockTime is enabled ([BIP-0065]).
     ///
-    /// [BIP-65]: https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki
+    /// [BIP-0065]: https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki
     fn is_lock_time_enabled(&self) -> bool;
 
     /// Returns an iterator over lengths of `script_pubkey`s in the outputs.
@@ -308,7 +348,7 @@ pub trait TransactionExt: sealed::Sealed {
     /// This is useful in combination with [`predict_weight`] if you have the transaction already
     /// constructed with a dummy value in the fee output which you'll adjust after calculating the
     /// weight.
-    fn script_pubkey_lens(&self) -> TxOutToScriptPubkeyLengthIter;
+    fn script_pubkey_lens(&self) -> TxOutToScriptPubkeyLengthIter<'_>;
 
     /// Counts the total number of sigops.
     ///
@@ -334,7 +374,7 @@ pub trait TransactionExt: sealed::Sealed {
 }
 
 impl TransactionExt for Transaction {
-    fn ntxid(&self) -> sha256d::Hash { self.compute_ntxid() }
+    fn ntxid(&self) -> Ntxid { self.compute_ntxid() }
 
     fn txid(&self) -> Txid { self.compute_txid() }
 
@@ -342,7 +382,7 @@ impl TransactionExt for Transaction {
 
     #[inline]
     fn weight(&self) -> Weight {
-        // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
+        // This is the exact definition of a weight unit, as defined by BIP-0141 (quote above).
         let wu = self.base_size() * 3 + self.total_size();
         Weight::from_wu(wu.to_u64())
     }
@@ -350,11 +390,11 @@ impl TransactionExt for Transaction {
     fn base_size(&self) -> usize {
         let mut size: usize = 4; // Serialized length of a u32 for the version number.
 
-        size += compact_size::encoded_size(self.input.len());
-        size += self.input.iter().map(|input| input.base_size()).sum::<usize>();
+        size += compact_size::encoded_size(self.inputs.len());
+        size += self.inputs.iter().map(|input| input.base_size()).sum::<usize>();
 
-        size += compact_size::encoded_size(self.output.len());
-        size += self.output.iter().map(|output| output.size()).sum::<usize>();
+        size += compact_size::encoded_size(self.outputs.len());
+        size += self.outputs.iter().map(|output| output.size()).sum::<usize>();
 
         size + absolute::LockTime::SIZE
     }
@@ -368,15 +408,15 @@ impl TransactionExt for Transaction {
             size += 2; // 1 byte for the marker and 1 for the flag.
         }
 
-        size += compact_size::encoded_size(self.input.len());
+        size += compact_size::encoded_size(self.inputs.len());
         size += self
-            .input
+            .inputs
             .iter()
             .map(|input| if uses_segwit { input.total_size() } else { input.base_size() })
             .sum::<usize>();
 
-        size += compact_size::encoded_size(self.output.len());
-        size += self.output.iter().map(|output| output.size()).sum::<usize>();
+        size += compact_size::encoded_size(self.outputs.len());
+        size += self.outputs.iter().map(|output| output.size()).sum::<usize>();
 
         size + absolute::LockTime::SIZE
     }
@@ -387,12 +427,7 @@ impl TransactionExt for Transaction {
         self.weight().to_vbytes_ceil() as usize
     }
 
-    #[doc(alias = "is_coin_base")] // method previously had this name
-    fn is_coinbase(&self) -> bool {
-        self.input.len() == 1 && self.input[0].previous_output == OutPoint::COINBASE_PREVOUT
-    }
-
-    fn is_explicitly_rbf(&self) -> bool { self.input.iter().any(|input| input.sequence.is_rbf()) }
+    fn is_explicitly_rbf(&self) -> bool { self.inputs.iter().any(|input| input.sequence.is_rbf()) }
 
     fn is_absolute_timelock_satisfied(&self, height: Height, time: MedianTimePast) -> bool {
         if !self.is_lock_time_enabled() {
@@ -401,10 +436,10 @@ impl TransactionExt for Transaction {
         self.lock_time.is_satisfied_by(height, time)
     }
 
-    fn is_lock_time_enabled(&self) -> bool { self.input.iter().any(|i| i.enables_lock_time()) }
+    fn is_lock_time_enabled(&self) -> bool { self.inputs.iter().any(|i| i.enables_lock_time()) }
 
-    fn script_pubkey_lens(&self) -> TxOutToScriptPubkeyLengthIter {
-        TxOutToScriptPubkeyLengthIter { inner: self.output.iter() }
+    fn script_pubkey_lens(&self) -> TxOutToScriptPubkeyLengthIter<'_> {
+        TxOutToScriptPubkeyLengthIter { inner: self.outputs.iter() }
     }
 
     fn total_sigop_cost<S>(&self, mut spent: S) -> usize
@@ -420,16 +455,16 @@ impl TransactionExt for Transaction {
 
     #[inline]
     fn tx_in(&self, input_index: usize) -> Result<&TxIn, InputsIndexError> {
-        self.input
+        self.inputs
             .get(input_index)
-            .ok_or(IndexOutOfBoundsError { index: input_index, length: self.input.len() }.into())
+            .ok_or(IndexOutOfBoundsError { index: input_index, length: self.inputs.len() }.into())
     }
 
     #[inline]
     fn tx_out(&self, output_index: usize) -> Result<&TxOut, OutputsIndexError> {
-        self.output
+        self.outputs
             .get(output_index)
-            .ok_or(IndexOutOfBoundsError { index: output_index, length: self.output.len() }.into())
+            .ok_or(IndexOutOfBoundsError { index: output_index, length: self.outputs.len() }.into())
     }
 }
 
@@ -463,7 +498,7 @@ trait TransactionExtPriv {
     where
         S: FnMut(&OutPoint) -> Option<TxOut>;
 
-    /// Returns whether or not to serialize transaction as specified in BIP-144.
+    /// Returns whether or not to serialize transaction as specified in BIP-0144.
     fn uses_segwit_serialization(&self) -> bool;
 }
 
@@ -471,11 +506,11 @@ impl TransactionExtPriv for Transaction {
     /// Gets the sigop count.
     fn count_p2pk_p2pkh_sigops(&self) -> usize {
         let mut count: usize = 0;
-        for input in &self.input {
+        for input in &self.inputs {
             // 0 for p2wpkh, p2wsh, and p2sh (including wrapped SegWit).
             count = count.saturating_add(input.script_sig.count_sigops_legacy());
         }
-        for output in &self.output {
+        for output in &self.outputs {
             count = count.saturating_add(output.script_pubkey.count_sigops_legacy());
         }
         count
@@ -490,15 +525,15 @@ impl TransactionExtPriv for Transaction {
             let mut count: usize = 0;
             if prevout.script_pubkey.is_p2sh() {
                 if let Some(redeem) = input.script_sig.last_pushdata() {
-                    count =
-                        count.saturating_add(Script::from_bytes(redeem.as_bytes()).count_sigops());
+                    count = count
+                        .saturating_add(RedeemScript::from_bytes(redeem.as_bytes()).count_sigops());
                 }
             }
             count
         }
 
         let mut count: usize = 0;
-        for input in &self.input {
+        for input in &self.inputs {
             if let Some(prevout) = spent(&input.previous_output) {
                 count = count.saturating_add(count_sigops(&prevout, input));
             }
@@ -511,16 +546,15 @@ impl TransactionExtPriv for Transaction {
     where
         S: FnMut(&OutPoint) -> Option<TxOut>,
     {
-        fn count_sigops_with_witness_program(witness: &Witness, witness_program: &Script) -> usize {
+        fn count_sigops_with_witness_program(
+            witness: &Witness,
+            witness_program: &ScriptPubKey,
+        ) -> usize {
             if witness_program.is_p2wpkh() {
                 1
             } else if witness_program.is_p2wsh() {
                 // Treat the last item of the witness as the witnessScript
-                return witness
-                    .last()
-                    .map(Script::from_bytes)
-                    .map(|s| s.count_sigops())
-                    .unwrap_or(0);
+                witness.last().map(WitnessScript::from_bytes).map(|s| s.count_sigops()).unwrap_or(0)
             } else {
                 0
             }
@@ -534,9 +568,11 @@ impl TransactionExtPriv for Transaction {
                 &prevout.script_pubkey
             } else if prevout.script_pubkey.is_p2sh() && script_sig.is_push_only() {
                 // If prevout is P2SH and scriptSig is push only
-                // then we wrap the last push (redeemScript) in a Script
+                // then we wrap the last push (redeemScript) in a Script; we use a ScriptPubKey to keep our types
+                // consistent although strictly speaking it should
+                // be a RedeemScript.
                 if let Some(push_bytes) = script_sig.last_pushdata() {
-                    Script::from_bytes(push_bytes.as_bytes())
+                    ScriptPubKey::from_bytes(push_bytes.as_bytes())
                 } else {
                     return 0;
                 }
@@ -549,7 +585,7 @@ impl TransactionExtPriv for Transaction {
         }
 
         let mut count: usize = 0;
-        for input in &self.input {
+        for input in &self.inputs {
             if let Some(prevout) = spent(&input.previous_output) {
                 count = count.saturating_add(count_sigops(prevout, input));
             }
@@ -557,15 +593,15 @@ impl TransactionExtPriv for Transaction {
         count
     }
 
-    /// Returns whether or not to serialize transaction as specified in BIP-144.
+    /// Returns whether or not to serialize transaction as specified in BIP-0144.
     // This is duplicated in `primitives`, if you change it please do so in both places.
     fn uses_segwit_serialization(&self) -> bool {
-        if self.input.iter().any(|input| !input.witness.is_empty()) {
+        if self.inputs.iter().any(|input| !input.witness.is_empty()) {
             return true;
         }
-        // To avoid serialization ambiguity, no inputs means we use BIP141 serialization (see
+        // To avoid serialization ambiguity, no inputs means we use BIP-0141 serialization (see
         // `Transaction` docs for full explanation).
-        self.input.is_empty()
+        self.inputs.is_empty()
     }
 }
 
@@ -636,11 +672,11 @@ impl Encodable for Version {
 
 impl Decodable for Version {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Decodable::consensus_decode(r).map(Version::maybe_non_standard)
+        Decodable::consensus_decode(r).map(Self::maybe_non_standard)
     }
 }
 
-impl_consensus_encoding!(TxOut, value, script_pubkey);
+internal_macros::impl_consensus_encoding!(TxOut, amount, script_pubkey);
 
 impl Encodable for OutPoint {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
@@ -650,10 +686,7 @@ impl Encodable for OutPoint {
 }
 impl Decodable for OutPoint {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(OutPoint {
-            txid: Decodable::consensus_decode(r)?,
-            vout: Decodable::consensus_decode(r)?,
-        })
+        Ok(Self { txid: Decodable::consensus_decode(r)?, vout: Decodable::consensus_decode(r)? })
     }
 }
 
@@ -671,7 +704,7 @@ impl Decodable for TxIn {
     fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
         r: &mut R,
     ) -> Result<Self, encode::Error> {
-        Ok(TxIn {
+        Ok(Self {
             previous_output: Decodable::consensus_decode_from_finite_reader(r)?,
             script_sig: Decodable::consensus_decode_from_finite_reader(r)?,
             sequence: Decodable::consensus_decode_from_finite_reader(r)?,
@@ -699,15 +732,15 @@ impl Encodable for Transaction {
 
         // Legacy transaction serialization format only includes inputs and outputs.
         if !self.uses_segwit_serialization() {
-            len += self.input.consensus_encode(w)?;
-            len += self.output.consensus_encode(w)?;
+            len += self.inputs.consensus_encode(w)?;
+            len += self.outputs.consensus_encode(w)?;
         } else {
-            // BIP-141 (SegWit) transaction serialization also includes marker, flag, and witness data.
+            // BIP-0141 (SegWit) transaction serialization also includes marker, flag, and witness data.
             len += SEGWIT_MARKER.consensus_encode(w)?;
             len += SEGWIT_FLAG.consensus_encode(w)?;
-            len += self.input.consensus_encode(w)?;
-            len += self.output.consensus_encode(w)?;
-            for input in &self.input {
+            len += self.inputs.consensus_encode(w)?;
+            len += self.outputs.consensus_encode(w)?;
+            for input in &self.inputs {
                 len += input.witness.consensus_encode(w)?;
             }
         }
@@ -721,27 +754,27 @@ impl Decodable for Transaction {
         r: &mut R,
     ) -> Result<Self, encode::Error> {
         let version = Version::consensus_decode_from_finite_reader(r)?;
-        let input = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
+        let inputs = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
         // SegWit
-        if input.is_empty() {
+        if inputs.is_empty() {
             let segwit_flag = u8::consensus_decode_from_finite_reader(r)?;
             match segwit_flag {
-                // BIP144 input witnesses
+                // BIP-0144 input witnesses
                 1 => {
-                    let mut input = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
-                    let output = Vec::<TxOut>::consensus_decode_from_finite_reader(r)?;
-                    for txin in input.iter_mut() {
+                    let mut inputs = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
+                    let outputs = Vec::<TxOut>::consensus_decode_from_finite_reader(r)?;
+                    for txin in inputs.iter_mut() {
                         txin.witness = Decodable::consensus_decode_from_finite_reader(r)?;
                     }
-                    if !input.is_empty() && input.iter().all(|input| input.witness.is_empty()) {
+                    if !inputs.is_empty() && inputs.iter().all(|input| input.witness.is_empty()) {
                         Err(consensus::parse_failed_error(
                             "witness flag set but no witnesses present",
                         ))
                     } else {
-                        Ok(Transaction {
+                        Ok(Self {
                             version,
-                            input,
-                            output,
+                            inputs,
+                            outputs,
                             lock_time: Decodable::consensus_decode_from_finite_reader(r)?,
                         })
                     }
@@ -751,10 +784,10 @@ impl Decodable for Transaction {
             }
         // non-SegWit
         } else {
-            Ok(Transaction {
+            Ok(Self {
                 version,
-                input,
-                output: Decodable::consensus_decode_from_finite_reader(r)?,
+                inputs,
+                outputs: Decodable::consensus_decode_from_finite_reader(r)?,
                 lock_time: Decodable::consensus_decode_from_finite_reader(r)?,
             })
         }
@@ -768,25 +801,22 @@ impl Decodable for Transaction {
 ///
 /// Note: the effective value of a [`Transaction`] may increase less than the effective value of
 /// a [`TxOut`] when adding another [`TxOut`] to the transaction. This happens when the new
-/// [`TxOut`] added causes the output length `VarInt` to increase its encoding length.
+/// [`TxOut`] added causes the output length `CompactSize` to increase its encoding length.
 ///
 /// # Parameters
 ///
 /// * `fee_rate` - the fee rate of the transaction being created.
 /// * `input_weight_prediction` - the predicted input weight.
-///
-/// # Returns
-///
-/// This will return [`NumOpResult::Error`] if the fee calculation (fee_rate * weight) overflows.
-/// Otherwise, [`NumOpResult::Valid`] will wrap the successful calculation.
+/// * `value` - the value of the output we are spending.
 pub fn effective_value(
     fee_rate: FeeRate,
     input_weight_prediction: InputWeightPrediction,
     value: Amount,
-) -> NumOpResult<SignedAmount> {
+) -> SignedAmount {
     let weight = input_weight_prediction.total_weight();
+    let fee = fee_rate.to_fee(weight);
 
-    fee_rate.to_fee(weight).map(Amount::to_signed).and_then(|fee| value.to_signed() - fee) // Cannot overflow.
+    value.signed_sub(fee)
 }
 
 /// Predicts the weight of a to-be-constructed transaction.
@@ -802,8 +832,7 @@ pub fn effective_value(
 ///   of the to-be-constructed transaction.
 ///
 /// Note that lengths of the scripts and witness elements must be non-serialized, IOW *without* the
-/// preceding compact size. The length of preceding compact size is computed and added inside the
-/// function for convenience.
+/// length prefix. The length is computed and added inside the function for convenience.
 ///
 /// If you have the transaction already constructed (except for signatures) with a dummy value for
 /// fee output you can use the return value of [`Transaction::script_pubkey_lens`] method directly
@@ -928,10 +957,10 @@ pub const fn predict_weight_from_slices(
 /// This helper type collects information about an input to be used in [`predict_weight`] function.
 /// It can only be created using the [`new`](InputWeightPrediction::new) function or using other
 /// associated constants/methods.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct InputWeightPrediction {
-    script_size: usize,
-    witness_size: usize,
+    script_size: u32,
+    witness_size: u32,
 }
 
 impl InputWeightPrediction {
@@ -945,7 +974,7 @@ impl InputWeightPrediction {
     /// under-paying. See [`ground_p2wpkh`](Self::ground_p2wpkh) if you do use signature grinding.
     ///
     /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
-    pub const P2WPKH_MAX: Self = InputWeightPrediction::from_slice(0, &[72, 33]);
+    pub const P2WPKH_MAX: Self = Self::from_slice(0, &[72, 33]);
 
     /// Input weight prediction corresponding to spending of [nested P2WPKH] output with the largest possible
     /// DER-encoded signature.
@@ -958,7 +987,7 @@ impl InputWeightPrediction {
     ///
     /// [nested P2WPKH]: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#p2wpkh-nested-in-bip16-p2sh
     /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
-    pub const NESTED_P2WPKH_MAX: Self = InputWeightPrediction::from_slice(23, &[72, 33]);
+    pub const NESTED_P2WPKH_MAX: Self = Self::from_slice(23, &[72, 33]);
 
     /// Input weight prediction corresponding to spending of a P2PKH output with the largest possible
     /// DER-encoded signature, and a compressed public key.
@@ -971,28 +1000,45 @@ impl InputWeightPrediction {
     /// signature grinding.
     ///
     /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
-    pub const P2PKH_COMPRESSED_MAX: Self = InputWeightPrediction::from_slice(107, &[]);
+    pub const P2PKH_COMPRESSED_MAX: Self = Self::from_slice(107, &[]);
 
     /// Input weight prediction corresponding to spending of a P2PKH output with the largest possible
     /// DER-encoded signature, and an uncompressed public key.
     ///
     /// If the input in your transaction uses P2PKH with an uncompressed key, you can use this instead of
     /// [`InputWeightPrediction::new`].
-    pub const P2PKH_UNCOMPRESSED_MAX: Self = InputWeightPrediction::from_slice(139, &[]);
+    pub const P2PKH_UNCOMPRESSED_MAX: Self = Self::from_slice(139, &[]);
 
     /// Input weight prediction corresponding to spending of Taproot output using the key and
     /// default sighash.
     ///
     /// If the input in your transaction uses Taproot key spend you can use this instead of
     /// [`InputWeightPrediction::new`].
-    pub const P2TR_KEY_DEFAULT_SIGHASH: Self = InputWeightPrediction::from_slice(0, &[64]);
+    pub const P2TR_KEY_DEFAULT_SIGHASH: Self = Self::from_slice(0, &[64]);
 
     /// Input weight prediction corresponding to spending of Taproot output using the key and
     /// **non**-default sighash.
     ///
     /// If the input in your transaction uses Taproot key spend you can use this instead of
     /// [`InputWeightPrediction::new`].
-    pub const P2TR_KEY_NON_DEFAULT_SIGHASH: Self = InputWeightPrediction::from_slice(0, &[65]);
+    pub const P2TR_KEY_NON_DEFAULT_SIGHASH: Self = Self::from_slice(0, &[65]);
+
+    const fn saturate_to_u32(x: usize) -> u32 {
+        if x > u32::MAX as usize {
+            u32::MAX
+        } else {
+            x as u32 //cast ok, condition prevents larger than u32::MAX.
+        }
+    }
+
+    const fn encoded_size(value: usize) -> u32 {
+        match value {
+            0..=0xFC => 1,
+            0xFD..=0xFFFF => 3,
+            0x10000..=0xFFFFFFFF => 5,
+            _ => 9,
+        }
+    }
 
     /// Input weight prediction corresponding to spending of P2WPKH output using [signature
     /// grinding].
@@ -1011,7 +1057,7 @@ impl InputWeightPrediction {
     pub const fn ground_p2wpkh(bytes_to_grind: usize) -> Self {
         // Written to trigger const/debug panic for unreasonably high values.
         let der_signature_size = 10 + (62 - bytes_to_grind);
-        InputWeightPrediction::from_slice(0, &[der_signature_size, 33])
+        Self::from_slice(0, &[der_signature_size, 33])
     }
 
     /// Input weight prediction corresponding to spending of [nested P2WPKH] output using [signature
@@ -1032,7 +1078,7 @@ impl InputWeightPrediction {
     pub const fn ground_nested_p2wpkh(bytes_to_grind: usize) -> Self {
         // Written to trigger const/debug panic for unreasonably high values.
         let der_signature_size = 10 + (62 - bytes_to_grind);
-        InputWeightPrediction::from_slice(23, &[der_signature_size, 33])
+        Self::from_slice(23, &[der_signature_size, 33])
     }
 
     /// Input weight prediction corresponding to spending of a P2PKH output using [signature
@@ -1053,7 +1099,7 @@ impl InputWeightPrediction {
         // Written to trigger const/debug panic for unreasonably high values.
         let der_signature_size = 10 + (62 - bytes_to_grind);
 
-        InputWeightPrediction::from_slice(2 + 33 + der_signature_size, &[])
+        Self::from_slice(2 + 33 + der_signature_size, &[])
     }
 
     /// Computes the prediction for a single input.
@@ -1063,18 +1109,19 @@ impl InputWeightPrediction {
         T::Item: Borrow<usize>,
     {
         let (count, total_size) = witness_element_lengths.into_iter().fold(
-            (0usize, 0),
+            (0usize, 0u32),
             |(count, total_size), elem_len| {
                 let elem_len = *elem_len.borrow();
-                let elem_size = elem_len + compact_size::encoded_size(elem_len);
-                (count + 1, total_size + elem_size)
+                let elem_size =
+                    Self::saturate_to_u32(elem_len).saturating_add(Self::encoded_size(elem_len));
+                (count + 1, total_size.saturating_add(elem_size))
             },
         );
-        let witness_size =
-            if count > 0 { total_size + compact_size::encoded_size(count) } else { 0 };
-        let script_size = input_script_len + compact_size::encoded_size(input_script_len);
+        let witness_size = if count > 0 { total_size + Self::encoded_size(count) } else { 0 };
+        let script_size =
+            Self::saturate_to_u32(input_script_len) + Self::encoded_size(input_script_len);
 
-        InputWeightPrediction { script_size, witness_size }
+        Self { script_size, witness_size }
     }
 
     /// Computes the prediction for a single input in `const` context.
@@ -1084,33 +1131,40 @@ impl InputWeightPrediction {
     /// `new` and thus is intended to be only used in `const` context.
     pub const fn from_slice(input_script_len: usize, witness_element_lengths: &[usize]) -> Self {
         let mut i = 0;
-        let mut total_size = 0;
+        let mut total_size: u32 = 0;
         // for loops not supported in const fn
         while i < witness_element_lengths.len() {
             let elem_len = witness_element_lengths[i];
-            let elem_size = elem_len + compact_size::encoded_size_const(elem_len as u64);
-            total_size += elem_size;
+            let elem_size =
+                Self::saturate_to_u32(elem_len).saturating_add(Self::encoded_size(elem_len));
+            total_size = total_size.saturating_add(elem_size);
             i += 1;
         }
         let witness_size = if !witness_element_lengths.is_empty() {
-            total_size + compact_size::encoded_size_const(witness_element_lengths.len() as u64)
+            total_size.saturating_add(Self::encoded_size(witness_element_lengths.len()))
         } else {
             0
         };
-        let script_size =
-            input_script_len + compact_size::encoded_size_const(input_script_len as u64);
+        let script_size = Self::saturate_to_u32(input_script_len)
+            .saturating_add(Self::encoded_size(input_script_len));
 
-        InputWeightPrediction { script_size, witness_size }
+        Self { script_size, witness_size }
     }
 
     /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
-    /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
+    /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count.
+    ///
+    /// This function's internal arithmetic saturates at u32::MAX, so the return value of this
+    /// function may be inaccurate for extremely large witness predictions.
     #[deprecated(since = "TBD", note = "use `InputWeightPrediction::witness_weight()` instead")]
     pub const fn weight(&self) -> Weight { Self::witness_weight(self) }
 
     /// Computes the signature, prevout (txid, index), and sequence weights of this weight
     /// prediction.
     ///
+    /// This function's internal arithmetic saturates at u32::MAX, so the return value of this
+    /// function may be inaccurate for extremely large witness predictions.
+    ///
     /// See also [`InputWeightPrediction::witness_weight`]
     pub const fn total_weight(&self) -> Weight {
         // `impl const Trait` is currently unavailable: rust/issues/67792
@@ -1120,16 +1174,70 @@ impl InputWeightPrediction {
     }
 
     /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
-    /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
+    /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count.
+    ///
+    /// This function's internal arithmetic saturates at u32::MAX, so the return value of this
+    /// function may be inaccurate for extremely large witness predictions.
     ///
     /// See also [`InputWeightPrediction::total_weight`]
     pub const fn witness_weight(&self) -> Weight {
         let wu = self.script_size * 4 + self.witness_size;
-        let wu = wu as u64; // Can't use `ToU64` in const context.
+        let wu = const_casts::u32_to_u64(wu);
         Weight::from_wu(wu)
     }
 }
 
+internals::transparent_newtype! {
+    /// A wrapper type for the coinbase transaction of a block.
+    ///
+    /// This type exists to distinguish coinbase transactions from regular ones at the type level.
+    #[derive(Clone, PartialEq, Eq, Debug, Hash)]
+    pub struct Coinbase(Transaction);
+
+    impl Coinbase {
+        /// Constructs a reference to `Coinbase` from a reference to the inner `Transaction`.
+        ///
+        /// This method does not validate that the transaction is actually a coinbase transaction.
+        /// The caller must ensure that the transaction is indeed a valid coinbase transaction
+        pub fn assume_coinbase_ref(inner: &_) -> &Self;
+    }
+}
+
+impl Coinbase {
+    /// Constructs a `Coinbase` wrapper assuming this transaction is a coinbase transaction.
+    ///
+    /// This method does not validate that the transaction is actually a coinbase transaction.
+    /// The caller must ensure that this transaction is indeed a valid coinbase transaction.
+    pub fn assume_coinbase(tx: Transaction) -> Self { Self(tx) }
+
+    /// Returns the first input of this coinbase transaction.
+    ///
+    /// This method is infallible because a valid coinbase transaction is guaranteed
+    /// to have exactly one input.
+    pub fn first_input(&self) -> &TxIn { &self.0.inputs[0] }
+
+    /// Returns a reference to the underlying transaction.
+    ///
+    /// Warning: The coinbase input contains dummy prevouts that should not be treated as real prevouts.
+    #[doc(alias = "as_inner")]
+    pub fn as_transaction(&self) -> &Transaction { &self.0 }
+
+    /// Returns the underlying transaction.
+    ///
+    /// Warning: The coinbase input contains dummy prevouts that should not be treated as real prevouts.
+    #[doc(alias = "into_inner")]
+    pub fn into_transaction(self) -> Transaction { self.0 }
+
+    /// Computes the [`Txid`] of this coinbase transaction.
+    pub fn compute_txid(&self) -> Txid { self.0.compute_txid() }
+
+    /// Returns the wtxid of this coinbase transaction.
+    ///
+    /// For coinbase transactions, this is always `Wtxid::COINBASE`.
+    #[doc(alias = "compute_wtxid")]
+    pub const fn wtxid(&self) -> Wtxid { Wtxid::COINBASE }
+}
+
 mod sealed {
     pub trait Sealed {}
     impl Sealed for super::Transaction {}
@@ -1141,17 +1249,40 @@ mod sealed {
     impl Sealed for super::Version {}
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for InputWeightPrediction {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=7)? {
+            0 => Ok(Self::P2WPKH_MAX),
+            1 => Ok(Self::NESTED_P2WPKH_MAX),
+            2 => Ok(Self::P2PKH_COMPRESSED_MAX),
+            3 => Ok(Self::P2PKH_UNCOMPRESSED_MAX),
+            4 => Ok(Self::P2TR_KEY_DEFAULT_SIGHASH),
+            5 => Ok(Self::P2TR_KEY_NON_DEFAULT_SIGHASH),
+            6 => {
+                let input_script_len = usize::arbitrary(u)?;
+                let witness_element_lengths: Vec<usize> = Vec::arbitrary(u)?;
+                Ok(Self::new(input_script_len, witness_element_lengths))
+            }
+            _ => {
+                let input_script_len = usize::arbitrary(u)?;
+                let witness_element_lengths: Vec<usize> = Vec::arbitrary(u)?;
+                Ok(Self::from_slice(input_script_len, &witness_element_lengths))
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use hex::FromHex;
     use hex_lit::hex;
-    #[cfg(feature = "serde")]
-    use internals::serde_round_trip;
-    use units::parse;
 
     use super::*;
     use crate::consensus::encode::{deserialize, serialize};
     use crate::constants::WITNESS_SCALE_FACTOR;
+    use crate::parse_int;
+    use crate::script::ScriptSigBuf;
     use crate::sighash::EcdsaSighashType;
 
     const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
@@ -1210,7 +1341,7 @@ mod tests {
         assert_eq!(
             "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol"
                 .parse::<OutPoint>(),
-            Err(ParseOutPointError::Vout(parse::int_from_str::<u32>("lol").unwrap_err()))
+            Err(ParseOutPointError::Vout(parse_int::int_from_str::<u32>("lol").unwrap_err()))
         );
 
         assert_eq!(
@@ -1262,15 +1393,15 @@ mod tests {
         // All these tests aren't really needed because if they fail, the hash check at the end
         // will also fail. But these will show you where the failure is so I'll leave them in.
         assert_eq!(realtx.version, Version::ONE);
-        assert_eq!(realtx.input.len(), 1);
+        assert_eq!(realtx.inputs.len(), 1);
         // In particular this one is easy to get backward -- in bitcoin hashes are encoded
         // as little-endian 256-bit numbers rather than as data strings.
         assert_eq!(
-            format!("{:x}", realtx.input[0].previous_output.txid),
+            format!("{:x}", realtx.inputs[0].previous_output.txid),
             "ce9ea9f6f5e422c6a9dbcddb3b9a14d1c78fab9ab520cb281aa2a74a09575da1".to_string()
         );
-        assert_eq!(realtx.input[0].previous_output.vout, 1);
-        assert_eq!(realtx.output.len(), 1);
+        assert_eq!(realtx.inputs[0].previous_output.vout, 1);
+        assert_eq!(realtx.outputs.len(), 1);
         assert_eq!(realtx.lock_time, absolute::LockTime::ZERO);
 
         assert_eq!(
@@ -1310,15 +1441,15 @@ mod tests {
         // All these tests aren't really needed because if they fail, the hash check at the end
         // will also fail. But these will show you where the failure is so I'll leave them in.
         assert_eq!(realtx.version, Version::TWO);
-        assert_eq!(realtx.input.len(), 1);
+        assert_eq!(realtx.inputs.len(), 1);
         // In particular this one is easy to get backward -- in bitcoin hashes are encoded
         // as little-endian 256-bit numbers rather than as data strings.
         assert_eq!(
-            format!("{:x}", realtx.input[0].previous_output.txid),
+            format!("{:x}", realtx.inputs[0].previous_output.txid),
             "7cac3cf9a112cf04901a51d605058615d56ffe6d04b45270e89d1720ea955859".to_string()
         );
-        assert_eq!(realtx.input[0].previous_output.vout, 1);
-        assert_eq!(realtx.output.len(), 1);
+        assert_eq!(realtx.inputs[0].previous_output.vout, 1);
+        assert_eq!(realtx.outputs.len(), 1);
         assert_eq!(realtx.lock_time, absolute::LockTime::ZERO);
 
         assert_eq!(
@@ -1339,7 +1470,7 @@ mod tests {
 
         // Construct a transaction without the witness data.
         let mut tx_without_witness = realtx;
-        tx_without_witness.input.iter_mut().for_each(|input| input.witness.clear());
+        tx_without_witness.inputs.iter_mut().for_each(|input| input.witness.clear());
         assert_eq!(tx_without_witness.total_size(), tx_without_witness.total_size());
         assert_eq!(tx_without_witness.total_size(), expected_strippedsize);
     }
@@ -1379,8 +1510,8 @@ mod tests {
         );
         let tx: Transaction = deserialize(&tx_bytes).expect("deserialize tx");
 
-        assert_eq!(tx.input.len(), 0);
-        assert_eq!(tx.output.len(), 1);
+        assert_eq!(tx.inputs.len(), 0);
+        assert_eq!(tx.outputs.len(), 1);
 
         let reser = serialize(&tx);
         assert_eq!(tx_bytes, *reser);
@@ -1397,10 +1528,10 @@ mod tests {
             "c3573dbea28ce24425c59a189391937e00d255150fa973d59d61caf3a06b601d"
         );
         // changing sigs does not affect it
-        tx.input[0].script_sig = ScriptBuf::new();
+        tx.inputs[0].script_sig = ScriptSigBuf::new();
         assert_eq!(old_ntxid, tx.compute_ntxid());
         // changing pks does
-        tx.output[0].script_pubkey = ScriptBuf::new();
+        tx.outputs[0].script_pubkey = ScriptPubKeyBuf::new();
         assert!(old_ntxid != tx.compute_ntxid());
     }
 
@@ -1471,28 +1602,6 @@ mod tests {
         );
     }
 
-    #[test]
-    #[cfg(feature = "serde")]
-    fn txn_encode_decode() {
-        let tx_bytes = hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000");
-        let tx: Transaction = deserialize(&tx_bytes).unwrap();
-        serde_round_trip!(tx);
-    }
-
-    // Test decoding transaction `4be105f158ea44aec57bf12c5817d073a712ab131df6f37786872cfc70734188`
-    // from testnet, which is the first BIP144-encoded transaction I encountered.
-    #[test]
-    #[cfg(feature = "serde")]
-    fn segwit_tx_decode() {
-        let tx_bytes = hex!("010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff3603da1b0e00045503bd5704c7dd8a0d0ced13bb5785010800000000000a636b706f6f6c122f4e696e6a61506f6f6c2f5345475749542fffffffff02b4e5a212000000001976a914876fbb82ec05caa6af7a3b5e5a983aae6c6cc6d688ac0000000000000000266a24aa21a9edf91c46b49eb8a29089980f02ee6b57e7d63d33b18b4fddac2bcd7db2a39837040120000000000000000000000000000000000000000000000000000000000000000000000000");
-        let tx: Transaction = deserialize(&tx_bytes).unwrap();
-        assert_eq!(tx.weight(), Weight::from_wu(780));
-        serde_round_trip!(tx);
-
-        let consensus_encoded = serialize(&tx);
-        assert_eq!(consensus_encoded, tx_bytes);
-    }
-
     #[test]
     fn sighashtype_fromstr_display() {
         let sighashtypes = [
@@ -1561,7 +1670,7 @@ mod tests {
         spending
             .verify(|point: &OutPoint| {
                 if let Some(tx) = spent.remove(&point.txid) {
-                    return tx.output.get(point.vout as usize).cloned();
+                    return tx.outputs.get(point.vout as usize).cloned();
                 }
                 None
             })
@@ -1569,27 +1678,27 @@ mod tests {
 
         // test that we fail with repeated use of same input
         let mut double_spending = spending.clone();
-        let re_use = double_spending.input[0].clone();
-        double_spending.input.push(re_use);
+        let re_use = double_spending.inputs[0].clone();
+        double_spending.inputs.push(re_use);
 
         assert!(double_spending
             .verify(|point: &OutPoint| {
                 if let Some(tx) = spent2.remove(&point.txid) {
-                    return tx.output.get(point.vout as usize).cloned();
+                    return tx.outputs.get(point.vout as usize).cloned();
                 }
                 None
             })
             .is_err());
 
         // test that we get a failure if we corrupt a signature
-        let mut witness = spending.input[1].witness.to_vec();
+        let mut witness = spending.inputs[1].witness.to_vec();
         witness[0][10] = 42;
-        spending.input[1].witness = Witness::from_slice(&witness);
+        spending.inputs[1].witness = Witness::from_slice(&witness);
 
         let error = spending
             .verify(|point: &OutPoint| {
                 if let Some(tx) = spent3.remove(&point.txid) {
-                    return tx.output.get(point.vout as usize).cloned();
+                    return tx.outputs.get(point.vout as usize).cloned();
                 }
                 None
             })
@@ -1658,10 +1767,9 @@ mod tests {
     fn effective_value_happy_path() {
         let value = "1 cBTC".parse::<Amount>().unwrap();
         let fee_rate = FeeRate::from_sat_per_kwu(10);
-        let effective_value =
-            effective_value(fee_rate, InputWeightPrediction::P2WPKH_MAX, value).unwrap();
+        let effective_value = effective_value(fee_rate, InputWeightPrediction::P2WPKH_MAX, value);
 
-        // 10 sat/kwu * 272 wu = 4 sats (rounding up)
+        // 10 sat/kwu * 272 wu = 3 sats (rounding up)
         let expected_fee = "3 sats".parse::<SignedAmount>().unwrap();
         let expected_effective_value = (value.to_signed() - expected_fee).unwrap();
         assert_eq!(effective_value, expected_effective_value);
@@ -1671,7 +1779,8 @@ mod tests {
     fn effective_value_fee_rate_does_not_overflow() {
         let eff_value =
             effective_value(FeeRate::MAX, InputWeightPrediction::P2WPKH_MAX, Amount::ZERO);
-        assert!(eff_value.is_error());
+        let want = SignedAmount::from_sat(-1254378597012250).unwrap(); // U64::MAX / 4_000 because of FeeRate::MAX
+        assert_eq!(eff_value, want)
     }
 
     #[test]
@@ -1695,8 +1804,8 @@ mod tests {
         let empty_transaction_weight = Transaction {
             version: Version::TWO,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![],
-            output: vec![],
+            inputs: vec![],
+            outputs: vec![],
         }
         .weight();
 
@@ -1706,8 +1815,8 @@ mod tests {
             assert_eq!(*is_segwit, tx.uses_segwit_serialization());
 
             let mut calculated_weight = empty_transaction_weight
-                + tx.input.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i))
-                + tx.output.iter().fold(Weight::ZERO, |sum, o| sum + o.weight());
+                + tx.inputs.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i))
+                + tx.outputs.iter().fold(Weight::ZERO, |sum, o| sum + o.weight());
 
             // The empty tx uses SegWit serialization but a legacy tx does not.
             if !tx.uses_segwit_serialization() {
@@ -1937,7 +2046,7 @@ mod tests {
     }
 
     #[test]
-    // needless_borrows_for_generic_args incorrecctly identifies &[] as a needless borrow
+    // needless_borrows_for_generic_args incorrectly identifies &[] as a needless borrow
     #[allow(clippy::needless_borrows_for_generic_args)]
     fn weight_prediction_new() {
         let p2wpkh_max = InputWeightPrediction::new(0, [72, 33]);
@@ -1993,12 +2102,7 @@ mod tests {
     }
 
     #[test]
-    fn sequence_debug_output() {
-        let seq = Sequence::from_seconds_floor(1000);
-        println!("{:?}", seq)
-    }
 
-    #[test]
     fn outpoint_format() {
         let outpoint = OutPoint::COINBASE_PREVOUT;
 
@@ -2020,65 +2124,23 @@ mod tests {
         let pretty_txid = "0x0000000000000000000000000000000000000000000000000000000000000000";
         assert_eq!(pretty_txid, format!("{:#}", &outpoint.txid));
     }
-}
-
-#[cfg(bench)]
-mod benches {
-    use io::sink;
-    use test::{black_box, Bencher};
-
-    use super::*;
-    use crate::consensus::{encode, Encodable};
-
-    const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
-
-    #[bench]
-    pub fn bench_transaction_size(bh: &mut Bencher) {
-        let mut tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
-
-        bh.iter(|| {
-            black_box(black_box(&mut tx).total_size());
-        });
-    }
 
-    #[bench]
-    pub fn bench_transaction_serialize(bh: &mut Bencher) {
-        let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
-        let mut data = Vec::with_capacity(SOME_TX.len());
-
-        bh.iter(|| {
-            let result = tx.consensus_encode(&mut data);
-            black_box(&result);
-            data.clear();
-        });
-    }
-
-    #[bench]
-    pub fn bench_transaction_serialize_logic(bh: &mut Bencher) {
-        let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
-
-        bh.iter(|| {
-            let size = tx.consensus_encode(&mut sink());
-            black_box(&size);
-        });
-    }
+    #[test]
+    fn coinbase_assume_methods() {
+        use crate::constants;
+        use crate::network::Network;
 
-    #[bench]
-    pub fn bench_transaction_deserialize(bh: &mut Bencher) {
-        // hex_lit does not work in bench code for some reason. Perhaps criterion fixes this.
-        let raw_tx = <Vec<u8> as hex::FromHex>::from_hex(SOME_TX).unwrap();
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let coinbase_tx = &genesis.transactions()[0];
 
-        bh.iter(|| {
-            let tx: Transaction = encode::deserialize(&raw_tx).unwrap();
-            black_box(&tx);
-        });
-    }
+        // Test that we can create a Coinbase reference using assume_coinbase_ref
+        let coinbase_ref = Coinbase::assume_coinbase_ref(coinbase_tx);
+        assert_eq!(coinbase_ref.compute_txid(), coinbase_tx.compute_txid());
+        assert_eq!(coinbase_ref.wtxid(), Wtxid::COINBASE);
 
-    #[bench]
-    pub fn bench_transaction_deserialize_hex(bh: &mut Bencher) {
-        bh.iter(|| {
-            let tx: Transaction = encode::deserialize_hex(SOME_TX).unwrap();
-            black_box(&tx);
-        });
+        // Test that we can create a Coinbase using assume_coinbase
+        let coinbase_owned = Coinbase::assume_coinbase(coinbase_tx.clone());
+        assert_eq!(coinbase_owned.compute_txid(), coinbase_tx.compute_txid());
+        assert_eq!(coinbase_owned.wtxid(), Wtxid::COINBASE);
     }
 }
diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index a4859a02b0..061db6960a 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -4,98 +4,26 @@
 //!
 //! This module contains the [`Witness`] struct and related methods to operate on it
 
-use internals::compact_size;
 use io::{BufRead, Write};
 
-use crate::consensus::encode::{self, Error, ReadExt, WriteExt, MAX_VEC_SIZE};
+use crate::consensus::encode::{self, Error, ParseError, WriteExt};
 use crate::consensus::{Decodable, Encodable};
 use crate::crypto::ecdsa;
 use crate::crypto::key::SerializedXOnlyPublicKey;
-use crate::prelude::Vec;
-#[cfg(doc)]
-use crate::script::ScriptExt as _;
 use crate::taproot::{self, ControlBlock, LeafScript, TaprootMerkleBranch, TAPROOT_ANNEX_PREFIX};
-use crate::Script;
+use crate::{internal_macros, TapScript, WitnessScript};
 
 type BorrowedControlBlock<'a> = ControlBlock<&'a TaprootMerkleBranch, &'a SerializedXOnlyPublicKey>;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use primitives::witness::{Iter, Witness};
+#[doc(no_inline)]
+pub use primitives::witness::UnexpectedEofError;
 
 impl Decodable for Witness {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
-        let witness_elements = r.read_compact_size()? as usize;
-        // Minimum size of witness element is 1 byte, so if the count is
-        // greater than MAX_VEC_SIZE we must return an error.
-        if witness_elements > MAX_VEC_SIZE {
-            return Err(encode::ParseError::OversizedVectorAllocation {
-                requested: witness_elements,
-                max: MAX_VEC_SIZE,
-            }
-            .into());
-        }
-        if witness_elements == 0 {
-            Ok(Witness::default())
-        } else {
-            // Leave space at the head for element positions.
-            // We will rotate them to the end of the Vec later.
-            let witness_index_space = witness_elements * 4;
-            let mut cursor = witness_index_space;
-
-            // this number should be determined as high enough to cover most witness, and low enough
-            // to avoid wasting space without reallocating
-            let mut content = vec![0u8; cursor + 128];
-
-            for i in 0..witness_elements {
-                let element_size = r.read_compact_size()? as usize;
-                let element_size_len = compact_size::encoded_size(element_size);
-                let required_len = cursor
-                    .checked_add(element_size)
-                    .ok_or(encode::Error::Parse(encode::ParseError::OversizedVectorAllocation {
-                        requested: usize::MAX,
-                        max: MAX_VEC_SIZE,
-                    }))?
-                    .checked_add(element_size_len)
-                    .ok_or(encode::Error::Parse(encode::ParseError::OversizedVectorAllocation {
-                        requested: usize::MAX,
-                        max: MAX_VEC_SIZE,
-                    }))?;
-
-                if required_len > MAX_VEC_SIZE + witness_index_space {
-                    return Err(encode::ParseError::OversizedVectorAllocation {
-                        requested: required_len,
-                        max: MAX_VEC_SIZE,
-                    }
-                    .into());
-                }
-
-                // We will do content.rotate_left(witness_index_space) later.
-                // Encode the position's value AFTER we rotate left.
-                encode_cursor(&mut content, 0, i, cursor - witness_index_space);
-
-                resize_if_needed(&mut content, required_len);
-                cursor += (&mut content[cursor..cursor + element_size_len])
-                    .emit_compact_size(element_size)?;
-                r.read_exact(&mut content[cursor..cursor + element_size])?;
-                cursor += element_size;
-            }
-            content.truncate(cursor);
-            // Index space is now at the end of the Vec
-            content.rotate_left(witness_index_space);
-            let indices_start = cursor - witness_index_space;
-            Ok(Witness::from_parts__unstable(content, witness_elements, indices_start))
-        }
-    }
-}
-
-fn resize_if_needed(vec: &mut Vec<u8>, required_len: usize) {
-    if required_len >= vec.len() {
-        let mut new_len = vec.len().max(1);
-        while new_len <= required_len {
-            new_len *= 2;
-        }
-        vec.resize(new_len, 0);
+        io::decode_from_read(r).map_err(|e| Error::Parse(ParseError::Witness(e)))
     }
 }
 
@@ -112,7 +40,7 @@ impl Encodable for Witness {
     }
 }
 
-crate::internal_macros::define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Witness`] type.
     pub trait WitnessExt impl for Witness {
         /// Constructs a new witness required to spend a P2WPKH output.
@@ -121,7 +49,7 @@ crate::internal_macros::define_extension_trait! {
         /// serialized public key. Also useful for spending a P2SH-P2WPKH output.
         ///
         /// It is expected that `pubkey` is related to the secret key used to create `signature`.
-        fn p2wpkh(signature: ecdsa::Signature, pubkey: secp256k1::PublicKey) -> Witness {
+        fn p2wpkh(signature: ecdsa::Signature, pubkey: secp256k1::PublicKey) -> Self {
             let mut witness = Witness::new();
             witness.push(signature.serialize());
             witness.push(pubkey.serialize());
@@ -129,14 +57,14 @@ crate::internal_macros::define_extension_trait! {
         }
 
         /// Constructs a new witness required to do a key path spend of a P2TR output.
-        fn p2tr_key_spend(signature: &taproot::Signature) -> Witness {
+        fn p2tr_key_spend(signature: &taproot::Signature) -> Self {
             let mut witness = Witness::new();
             witness.push(signature.serialize());
             witness
         }
 
         /// Finishes constructing the P2TR script spend witness by pushing the required items.
-        fn push_p2tr_script_spend(&mut self, script: &Script, control_block: &ControlBlock<impl AsRef<TaprootMerkleBranch>>, annex: Option<&[u8]>) {
+        fn push_p2tr_script_spend(&mut self, script: &TapScript, control_block: &ControlBlock<impl AsRef<TaprootMerkleBranch>>, annex: Option<&[u8]>) {
             self.push(script.as_bytes());
             self.push(&*control_block.encode_to_arrayvec());
             if let Some(annex) = annex {
@@ -151,30 +79,31 @@ crate::internal_macros::define_extension_trait! {
             self.push(signature.serialize())
         }
 
-        /// Get Tapscript following BIP341 rules regarding accounting for an annex.
-        ///
-        /// This does not guarantee that this represents a P2TR [`Witness`]. It
-        /// merely gets the second to last or third to last element depending on
-        /// the first byte of the last element being equal to 0x50.
+        /// Returns the leaf script if this witness is a Taproot script spend.
         ///
-        /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
-        fn tapscript(&self) -> Option<&Script> {
+        /// **Deprecated** since this does not return the leaf version. Code that
+        /// assumes a leaf version may be subtly broken once a new Tapscript version
+        /// is deployed.
+        #[deprecated(since = "TBD", note = "use taproot_leaf_script instead")]
+        fn tapscript(&self) -> Option<&TapScript> {
             match P2TrSpend::from_witness(self) {
-                // Note: the method is named "tapscript" but historically it was actually returning
-                // leaf script. This is broken but we now keep the behavior the same to not subtly
-                // break someone.
                 Some(P2TrSpend::Script { leaf_script, .. }) => Some(leaf_script),
                 _ => None,
             }
         }
 
-        /// Returns the leaf script with its version but without the merkle proof.
+        /// Returns the leaf script and version if this witness is a Taproot script spend.
+        ///
+        /// This method does not include the control block or annex; to obtain those, call
+        /// [`Self::taproot_control_block`] and [`Self::taproot_annex`].
         ///
-        /// This does not guarantee that this represents a P2TR [`Witness`]. It
-        /// merely gets the second to last or third to last element depending on
-        /// the first byte of the last element being equal to 0x50 and the associated
-        /// version.
-        fn taproot_leaf_script(&self) -> Option<LeafScript<&Script>> {
+        /// Although this method does not have access to the output being spent, if the
+        /// transaction is valid and this method returns `Some`, you can be assured that
+        /// it is a real Taproot script spend (and not some other kind of output contrived
+        /// to have a Taproot-shaped witness).
+        /// See [BIP-0341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki),
+        /// in particular footnote 7, for more information.
+        fn taproot_leaf_script(&self) -> Option<LeafScript<&TapScript>> {
             match P2TrSpend::from_witness(self) {
                 Some(P2TrSpend::Script { leaf_script, control_block, .. }) => {
                     Some(LeafScript { version: control_block.leaf_version, script: leaf_script, })
@@ -183,13 +112,14 @@ crate::internal_macros::define_extension_trait! {
             }
         }
 
-        /// Get the Taproot control block following BIP341 rules.
+        /// If this witness is a Taproot script spend, return the control block.
         ///
-        /// This does not guarantee that this represents a P2TR [`Witness`]. It
-        /// merely gets the last or second to last element depending on the first
-        /// byte of the last element being equal to 0x50.
-        ///
-        /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
+        /// Although this method does not have access to the output being spent, if the
+        /// transaction is valid and this method returns `Some`, you can be assured that
+        /// it is a real Taproot script spend (and not some other kind of output contrived
+        /// to have a Taproot-shaped witness).
+        /// See [BIP-0341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki),
+        /// in particular footnote 7, for more information.
         fn taproot_control_block(&self) -> Option<BorrowedControlBlock<'_>> {
             match P2TrSpend::from_witness(self) {
                 Some(P2TrSpend::Script { control_block, .. }) => Some(control_block),
@@ -197,22 +127,18 @@ crate::internal_macros::define_extension_trait! {
             }
         }
 
-        /// Get the Taproot annex following BIP341 rules.
-        ///
-        /// This does not guarantee that this represents a P2TR [`Witness`].
-        ///
-        /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
+        /// If this witness is a Taproot script spend with an annex, return that.
         fn taproot_annex(&self) -> Option<&[u8]> {
             P2TrSpend::from_witness(self)?.annex()
         }
 
-        /// Get the p2wsh witness script following BIP141 rules.
+        /// Get the Segwit version 0 witness script.
         ///
-        /// This does not guarantee that this represents a P2WS [`Witness`].
-        ///
-        /// See [`Script::is_p2wsh`] to check whether this is actually a P2WSH witness.
-        fn witness_script(&self) -> Option<&Script> { self.last().map(Script::from_bytes) }
-
+        /// Unlike the Taproot case, we do no validation to determine whether this is a
+        /// witness script: it may be a Taproot control block, annex, or some other kind
+        /// of object. If you are not certain whether the output being spent is Segwit v0,
+        /// use [`crate::script::ScriptExt::is_p2wsh`] on the output's script.
+        fn witness_script(&self) -> Option<&WitnessScript> { self.last().map(WitnessScript::from_bytes) }
     }
 }
 
@@ -234,7 +160,7 @@ enum P2TrSpend<'a> {
         annex: Option<&'a [u8]>,
     },
     Script {
-        leaf_script: &'a Script,
+        leaf_script: &'a TapScript,
         control_block: BorrowedControlBlock<'a>,
         annex: Option<&'a [u8]>,
     },
@@ -251,7 +177,7 @@ impl<'a> P2TrSpend<'a> {
     /// obtained from Bitcoin Core) then it's OK to unwrap this but not vice versa - `Some` does
     /// not imply correctness.
     fn from_witness(witness: &'a Witness) -> Option<Self> {
-        // BIP341 says:
+        // BIP-0341 says:
         //   If there are at least two witness elements, and the first byte of
         //   the last element is 0x50, this last element is called annex a
         //   and is removed from the witness stack.
@@ -277,7 +203,7 @@ impl<'a> P2TrSpend<'a> {
                 let control_block = witness.get_back(1).expect("len > 1");
                 let control_block = BorrowedControlBlock::decode_borrowed(control_block).ok()?;
                 let spend = P2TrSpend::Script {
-                    leaf_script: Script::from_bytes(witness.get_back(2).expect("len > 2")),
+                    leaf_script: TapScript::from_bytes(witness.get_back(2).expect("len > 2")),
                     control_block,
                     annex: witness.last(),
                 };
@@ -287,7 +213,7 @@ impl<'a> P2TrSpend<'a> {
                 let control_block = witness.last().expect("len > 0");
                 let control_block = BorrowedControlBlock::decode_borrowed(control_block).ok()?;
                 let spend = P2TrSpend::Script {
-                    leaf_script: Script::from_bytes(witness.get_back(1).expect("len > 1")),
+                    leaf_script: TapScript::from_bytes(witness.get_back(1).expect("len > 1")),
                     control_block,
                     annex: None,
                 };
@@ -309,16 +235,6 @@ mod sealed {
     impl Sealed for super::Witness {}
 }
 
-/// Correctness Requirements: value must always fit within u32
-// This is duplicated in `primitives::witness`, if you change it please do so over there also.
-#[inline]
-fn encode_cursor(bytes: &mut [u8], start_of_indices: usize, index: usize, value: usize) {
-    let start = start_of_indices + index * 4;
-    let end = start + 4;
-    bytes[start..end]
-        .copy_from_slice(&u32::to_ne_bytes(value.try_into().expect("larger than u32")));
-}
-
 #[cfg(test)]
 mod test {
     use hex_lit::hex;
@@ -381,8 +297,8 @@ mod test {
         let got_ser = encode::serialize(&got_witness);
         assert_eq!(got_ser, want_ser);
 
-        let rinsed: Witness = encode::deserialize(&got_ser).unwrap();
-        assert_eq!(rinsed, want_witness)
+        let roundtrip: Witness = encode::deserialize(&got_ser).unwrap();
+        assert_eq!(roundtrip, want_witness)
     }
 
     #[test]
@@ -397,8 +313,8 @@ mod test {
         let witness_annex = Witness::from([tapscript.as_slice(), &control_block, &annex]);
 
         // With or without annex, the tapscript should be returned.
-        assert_eq!(witness.tapscript(), Some(Script::from_bytes(&tapscript[..])));
-        assert_eq!(witness_annex.tapscript(), Some(Script::from_bytes(&tapscript[..])));
+        assert_eq!(witness.tapscript(), Some(TapScript::from_bytes(&tapscript[..])));
+        assert_eq!(witness_annex.tapscript(), Some(TapScript::from_bytes(&tapscript[..])));
     }
 
     #[test]
@@ -412,8 +328,10 @@ mod test {
         let witness = Witness::from([tapscript.as_slice(), &control_block]);
         let witness_annex = Witness::from([tapscript.as_slice(), &control_block, &annex]);
 
-        let expected_leaf_script =
-            LeafScript { version: LeafVersion::TapScript, script: Script::from_bytes(&tapscript) };
+        let expected_leaf_script = LeafScript {
+            version: LeafVersion::TapScript,
+            script: TapScript::from_bytes(&tapscript),
+        };
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_leaf_script().unwrap(), expected_leaf_script);
@@ -489,16 +407,19 @@ mod test {
         let tx: Transaction = deserialize(&tx_bytes).unwrap();
 
         let expected_wit = ["304502210084622878c94f4c356ce49c8e33a063ec90f6ee9c0208540888cfab056cd1fca9022014e8dbfdfa46d318c6887afd92dcfa54510e057565e091d64d2ee3a66488f82c01", "026e181ffb98ebfe5a64c983073398ea4bcd1548e7b971b4c175346a25a1c12e95"];
-        for (i, wit_el) in tx.input[0].witness.iter().enumerate() {
+        for (i, wit_el) in tx.inputs[0].witness.iter().enumerate() {
             assert_eq!(expected_wit[i], wit_el.to_lower_hex_string());
         }
-        assert_eq!(expected_wit[1], tx.input[0].witness.last().unwrap().to_lower_hex_string());
-        assert_eq!(expected_wit[0], tx.input[0].witness.get_back(1).unwrap().to_lower_hex_string());
-        assert_eq!(expected_wit[0], tx.input[0].witness.get(0).unwrap().to_lower_hex_string());
-        assert_eq!(expected_wit[1], tx.input[0].witness.get(1).unwrap().to_lower_hex_string());
-        assert_eq!(None, tx.input[0].witness.get(2));
-        assert_eq!(expected_wit[0], tx.input[0].witness[0].to_lower_hex_string());
-        assert_eq!(expected_wit[1], tx.input[0].witness[1].to_lower_hex_string());
+        assert_eq!(expected_wit[1], tx.inputs[0].witness.last().unwrap().to_lower_hex_string());
+        assert_eq!(
+            expected_wit[0],
+            tx.inputs[0].witness.get_back(1).unwrap().to_lower_hex_string()
+        );
+        assert_eq!(expected_wit[0], tx.inputs[0].witness.get(0).unwrap().to_lower_hex_string());
+        assert_eq!(expected_wit[1], tx.inputs[0].witness.get(1).unwrap().to_lower_hex_string());
+        assert_eq!(None, tx.inputs[0].witness.get(2));
+        assert_eq!(expected_wit[0], tx.inputs[0].witness[0].to_lower_hex_string());
+        assert_eq!(expected_wit[1], tx.inputs[0].witness[1].to_lower_hex_string());
 
         let tx_bytes_back = serialize(&tx);
         assert_eq!(tx_bytes_back, tx_bytes);
@@ -513,30 +434,3 @@ mod test {
         assert!(deserialize::<Witness>(&bytes).is_err()); // OversizedVectorAllocation
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::{black_box, Bencher};
-
-    use super::{Witness, WitnessExt};
-
-    #[bench]
-    pub fn bench_big_witness_to_vec(bh: &mut Bencher) {
-        let raw_witness = [[1u8]; 5];
-        let witness = Witness::from_slice(&raw_witness);
-
-        bh.iter(|| {
-            black_box(witness.to_vec());
-        });
-    }
-
-    #[bench]
-    pub fn bench_witness_to_vec(bh: &mut Bencher) {
-        let raw_witness = vec![vec![1u8]; 3];
-        let witness = Witness::from_slice(&raw_witness);
-
-        bh.iter(|| {
-            black_box(witness.to_vec());
-        });
-    }
-}
diff --git a/bitcoin/src/consensus/encode.rs b/bitcoin/src/consensus/encode.rs
index 3620c1867b..baa5003060 100644
--- a/bitcoin/src/consensus/encode.rs
+++ b/bitcoin/src/consensus/encode.rs
@@ -14,7 +14,8 @@
 //! scripts come with an opcode decode, hashes are big-endian, numbers are
 //! typically big-endian decimals, etc.)
 
-use core::mem;
+use core::any::TypeId;
+use core::{cmp, mem, slice};
 
 use hashes::{sha256, sha256d, Hash};
 use hex::DisplayHex as _;
@@ -22,18 +23,8 @@ use internals::{compact_size, ToU64};
 use io::{BufRead, Cursor, Read, Write};
 
 use super::IterReader;
-use crate::bip152::{PrefilledTransaction, ShortId};
-use crate::bip158::{FilterHash, FilterHeader};
-use crate::block::{self, BlockHash};
-use crate::merkle_tree::TxMerkleNode;
-#[cfg(feature = "std")]
-use crate::p2p::{
-    address::{AddrV2Message, Address},
-    message_blockdata::Inventory,
-};
 use crate::prelude::{rc, sync, Box, Cow, String, Vec};
 use crate::taproot::TapLeafHash;
-use crate::transaction::{Transaction, TxIn, TxOut};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use super::{Error, FromHexError, ParseError, DeserializeError};
@@ -64,7 +55,7 @@ pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T, DeserializeError> {
     }
 }
 
-/// Deserialize any decodable type from a hex string, will error if said deserialization
+/// Deserializes any decodable type from a hex string, will error if said deserialization
 /// doesn't consume the entire vector.
 pub fn deserialize_hex<T: Decodable>(hex: &str) -> Result<T, FromHexError> {
     let iter = hex::HexSliceToBytesIter::new(hex)?;
@@ -230,7 +221,7 @@ impl<R: Read + ?Sized> ReadExt for R {
             0xFF => {
                 let x = self.read_u64()?;
                 if x < 0x1_0000_0000 { // I.e., would have fit in a `u32`.
-                    Err(ParseError::NonMinimalVarInt.into())
+                    Err(ParseError::NonMinimalCompactSize.into())
                 } else {
                     Ok(x)
                 }
@@ -238,7 +229,7 @@ impl<R: Read + ?Sized> ReadExt for R {
             0xFE => {
                 let x = self.read_u32()?;
                 if x < 0x1_0000 { // I.e., would have fit in a `u16`.
-                    Err(ParseError::NonMinimalVarInt.into())
+                    Err(ParseError::NonMinimalCompactSize.into())
                 } else {
                     Ok(x as u64)
                 }
@@ -246,7 +237,7 @@ impl<R: Read + ?Sized> ReadExt for R {
             0xFD => {
                 let x = self.read_u16()?;
                 if x < 0xFD {   // Could have been encoded as a `u8`.
-                    Err(ParseError::NonMinimalVarInt.into())
+                    Err(ParseError::NonMinimalCompactSize.into())
                 } else {
                     Ok(x as u64)
                 }
@@ -270,9 +261,9 @@ pub trait Encodable {
     fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error>;
 }
 
-/// Data which can be encoded in a consensus-consistent way.
+/// Data which can be decoded in a consensus-consistent way.
 pub trait Decodable: Sized {
-    /// Decode `Self` from a size-limited reader.
+    /// Decodes `Self` from a size-limited reader.
     ///
     /// Like `consensus_decode` but relies on the reader being limited in the amount of data it
     /// returns, e.g. by being wrapped in [`std::io::Take`].
@@ -289,7 +280,7 @@ pub trait Decodable: Sized {
     /// * Simple types that have a fixed size (own and member fields), don't have to overwrite
     ///   this method, or be concern with it.
     /// * Types that deserialize using externally provided length should implement it:
-    ///   * Make `consensus_decode` forward to `consensus_decode_bytes_from_finite_reader` with the
+    ///   * Make `consensus_decode` forward to `consensus_decode_from_finite_reader` with the
     ///     reader wrapped by `Take`. Failure to do so, without other forms of memory exhaustion
     ///     protection might lead to resource exhaustion vulnerability.
     ///   * Put a max cap on things like `Vec::with_capacity` to avoid oversized allocations, and
@@ -310,7 +301,7 @@ pub trait Decodable: Sized {
         Self::consensus_decode(reader)
     }
 
-    /// Decode an object with a well-defined format.
+    /// Decodes an object with a well-defined format.
     ///
     /// This is the method that should be implemented for a typical, fixed sized type
     /// implementing this trait. Default implementation is wrapping the reader
@@ -324,30 +315,6 @@ pub trait Decodable: Sized {
     }
 }
 
-/// Data and a 4-byte checksum.
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CheckedData {
-    data: Vec<u8>,
-    checksum: [u8; 4],
-}
-
-impl CheckedData {
-    /// Constructs a new `CheckedData` computing the checksum of given data.
-    pub fn new(data: Vec<u8>) -> Self {
-        let checksum = sha2_checksum(&data);
-        Self { data, checksum }
-    }
-
-    /// Returns a reference to the raw data without the checksum.
-    pub fn data(&self) -> &[u8] { &self.data }
-
-    /// Returns the raw data without the checksum.
-    pub fn into_data(self) -> Vec<u8> { self.data }
-
-    /// Returns the checksum of the data.
-    pub fn checksum(&self) -> [u8; 4] { self.checksum }
-}
-
 // Primitive types
 macro_rules! impl_int_encodable {
     ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
@@ -406,7 +373,7 @@ impl Encodable for bool {
 
 impl Decodable for bool {
     #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<bool, Error> {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
         ReadExt::read_bool(r)
     }
 }
@@ -420,8 +387,8 @@ impl Encodable for String {
 
 impl Decodable for String {
     #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<String, Error> {
-        String::from_utf8(Decodable::consensus_decode(r)?)
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        Self::from_utf8(Decodable::consensus_decode(r)?)
             .map_err(|_| super::parse_failed_error("String was not valid UTF8"))
     }
 }
@@ -435,7 +402,7 @@ impl Encodable for Cow<'static, str> {
 
 impl Decodable for Cow<'static, str> {
     #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Cow<'static, str>, Error> {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
         String::from_utf8(Decodable::consensus_decode(r)?)
             .map_err(|_| super::parse_failed_error("String was not valid UTF8"))
             .map(Cow::Owned)
@@ -499,65 +466,41 @@ impl Encodable for [u16; 8] {
     }
 }
 
-macro_rules! impl_vec {
-    ($type: ty) => {
-        impl Encodable for Vec<$type> {
-            #[inline]
-            fn consensus_encode<W: Write + ?Sized>(
-                &self,
-                w: &mut W,
-            ) -> core::result::Result<usize, io::Error> {
-                let mut len = 0;
-                len += w.emit_compact_size(self.len())?;
-                for c in self.iter() {
-                    len += c.consensus_encode(w)?;
-                }
-                Ok(len)
-            }
-        }
+impl<T: Encodable + 'static> Encodable for Vec<T> {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self[..].consensus_encode(w)
+    }
+}
 
-        impl Decodable for Vec<$type> {
-            #[inline]
-            fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
-                r: &mut R,
-            ) -> core::result::Result<Self, Error> {
-                let len = r.read_compact_size()?;
-                // Do not allocate upfront more items than if the sequence of type
-                // occupied roughly quarter a block. This should never be the case
-                // for normal data, but even if that's not true - `push` will just
-                // reallocate.
-                // Note: OOM protection relies on reader eventually running out of
-                // data to feed us.
-                let max_capacity = MAX_VEC_SIZE / 4 / mem::size_of::<$type>();
-                let mut ret = Vec::with_capacity(core::cmp::min(len as usize, max_capacity));
-                for _ in 0..len {
-                    ret.push(Decodable::consensus_decode_from_finite_reader(r)?);
-                }
-                Ok(ret)
+impl<T: Decodable + 'static> Decodable for Vec<T> {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() {
+            let len = r.read_compact_size()? as usize;
+            // most real-world vec of bytes data, wouldn't be larger than 128KiB
+            let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 };
+            let bytes = read_bytes_from_finite_reader(r, opts)?;
+
+            // unsafe: We've just checked that T is `u8` so the transmute here is a no-op.
+            unsafe { Ok(mem::transmute::<Vec<u8>, Self>(bytes)) }
+        } else {
+            let len = r.read_compact_size()?;
+            // Limit the initial vec allocation to at most 8,000 bytes, which is
+            // sufficient for most use cases. We don't allocate more space upfront
+            // than this, since `len` is an untrusted allocation capacity. If the
+            // vector does overflow the initial capacity `push` will just reallocate.
+            // Note: OOM protection relies on reader eventually running out of
+            // data to feed us.
+            let max_init_capacity = 8000 / mem::size_of::<T>();
+            let mut ret = Self::with_capacity(cmp::min(len as usize, max_init_capacity));
+            for _ in 0..len {
+                ret.push(Decodable::consensus_decode_from_finite_reader(r)?);
             }
+            Ok(ret)
         }
-    };
+    }
 }
-impl_vec!(BlockHash);
-impl_vec!(block::Header);
-impl_vec!(FilterHash);
-impl_vec!(FilterHeader);
-impl_vec!(TxMerkleNode);
-impl_vec!(Transaction);
-impl_vec!(TxOut);
-impl_vec!(TxIn);
-impl_vec!(Vec<u8>);
-impl_vec!(u64);
-impl_vec!(TapLeafHash);
-impl_vec!(ShortId);
-impl_vec!(PrefilledTransaction);
-
-#[cfg(feature = "std")]
-impl_vec!(Inventory);
-#[cfg(feature = "std")]
-impl_vec!((u32, Address));
-#[cfg(feature = "std")]
-impl_vec!(AddrV2Message);
 
 pub(crate) fn consensus_encode_with_size<W: Write + ?Sized>(
     data: &[u8],
@@ -596,23 +539,6 @@ fn read_bytes_from_finite_reader<D: Read + ?Sized>(
     Ok(ret)
 }
 
-impl Encodable for Vec<u8> {
-    #[inline]
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        consensus_encode_with_size(self, w)
-    }
-}
-
-impl Decodable for Vec<u8> {
-    #[inline]
-    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
-        let len = r.read_compact_size()? as usize;
-        // most real-world vec of bytes data, wouldn't be larger than 128KiB
-        let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 };
-        read_bytes_from_finite_reader(r, opts)
-    }
-}
-
 impl Encodable for Box<[u8]> {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
@@ -627,38 +553,29 @@ impl Decodable for Box<[u8]> {
     }
 }
 
-/// Does a double-SHA256 on `data` and returns the first 4 bytes.
-fn sha2_checksum(data: &[u8]) -> [u8; 4] {
-    let checksum = sha256d::hash(data);
-    let checksum = checksum.to_byte_array();
-    [checksum[0], checksum[1], checksum[2], checksum[3]]
-}
-
-impl Encodable for CheckedData {
+impl<T: Encodable + 'static> Encodable for [T] {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        u32::try_from(self.data.len())
-            .expect("network message use u32 as length")
-            .consensus_encode(w)?;
-        self.checksum().consensus_encode(w)?;
-        Ok(8 + w.emit_slice(&self.data)?)
+        (&self).consensus_encode(w)
     }
 }
 
-impl Decodable for CheckedData {
+impl<T: Encodable + 'static> Encodable for &[T] {
     #[inline]
-    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
-        let len = u32::consensus_decode_from_finite_reader(r)? as usize;
-
-        let checksum = <[u8; 4]>::consensus_decode_from_finite_reader(r)?;
-        let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: MAX_VEC_SIZE };
-        let data = read_bytes_from_finite_reader(r, opts)?;
-        let expected_checksum = sha2_checksum(&data);
-        if expected_checksum != checksum {
-            Err(ParseError::InvalidChecksum { expected: expected_checksum, actual: checksum }
-                .into())
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() {
+            let len = self.len();
+            let ptr = self.as_ptr();
+
+            // unsafe: We've just checked that T is `u8`.
+            let v = unsafe { slice::from_raw_parts(ptr.cast::<u8>(), len) };
+            consensus_encode_with_size(v, w)
         } else {
-            Ok(CheckedData { data, checksum })
+            let mut len = w.emit_compact_size(self.len())?;
+            for c in self.iter() {
+                len += c.consensus_encode(w)?;
+            }
+            Ok(len)
         }
     }
 }
@@ -765,8 +682,10 @@ mod tests {
     use core::mem::discriminant;
 
     use super::*;
-    #[cfg(feature = "std")]
-    use crate::p2p::{message_blockdata::Inventory, Address};
+    use crate::block::BlockHash;
+    use crate::merkle_tree::TxMerkleNode;
+    use crate::prelude::{Cow, Vec};
+    use crate::transaction::{Transaction, TxIn, TxOut};
 
     #[test]
     fn serialize_int() {
@@ -824,6 +743,57 @@ mod tests {
         (&input[..]).read_compact_size()
     }
 
+    #[test]
+    fn encode_t_slice() {
+        // Multi-element u8 case
+        let enc_buf = serialize(&[1u8, 2, 3, 4].as_slice());
+        assert_eq!(enc_buf, [4u8, 1, 2, 3, 4]);
+
+        // Empty u64 case
+        let enc_buf = serialize::<&[u64]>(&[0u64; 0].as_slice());
+        assert_eq!(enc_buf, [0u8]);
+
+        // multi-element u32 case
+        let enc_buf = serialize(&[654321u32, 123456].as_slice());
+        assert_eq!(enc_buf, [2u8, 241, 251, 9, 0, 64, 226, 1, 0])
+    }
+
+    #[test]
+    fn encode_u8_slice() {
+        // Multi-element case
+        let enc_buf = serialize([1u8, 2, 3, 4].as_slice());
+        assert_eq!(enc_buf, [4u8, 1, 2, 3, 4]);
+
+        // Empty case
+        let enc_buf = serialize::<[u8]>([0u8; 0].as_slice());
+        assert_eq!(enc_buf, [0u8]);
+
+        // Single-element case
+        let enc_buf = serialize([42u8].as_slice());
+        assert_eq!(enc_buf, [1u8, 42]);
+    }
+
+    #[test]
+    fn encode_u8_slice_matches_vec() {
+        let assert_vec_eq = |data: Vec<u8>| {
+            let enc_buf = serialize::<[u8]>(data.as_slice());
+            let vec_enc_buf = serialize::<Vec<u8>>(&data);
+            assert_eq!(enc_buf, vec_enc_buf);
+        };
+
+        // Multi-element case
+        let data = vec![1u8, 2, 3, 4];
+        assert_vec_eq(data);
+
+        // Empty case
+        let data = Vec::new();
+        assert_vec_eq(data);
+
+        // Single-element case
+        let data = vec![42u8];
+        assert_vec_eq(data);
+    }
+
     #[test]
     fn serialize_varint() {
         fn encode(v: u64) -> Vec<u8> {
@@ -865,50 +835,50 @@ mod tests {
             discriminant(
                 &test_varint_encode(0xFF, &(0x100000000_u64 - 1).to_le_bytes()).unwrap_err()
             ),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&test_varint_encode(0xFE, &(0x10000_u64 - 1).to_le_bytes()).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&test_varint_encode(0xFD, &(0xFD_u64 - 1).to_le_bytes()).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
 
         assert_eq!(
             discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0x00, 0x00]).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&deserialize::<Vec<u8>>(&[0xfe, 0xff, 0x00, 0x00, 0x00]).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(&deserialize::<Vec<u8>>(&[0xfe, 0xff, 0xff, 0x00, 0x00]).unwrap_err()),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(
                 &deserialize::<Vec<u8>>(&[0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
                     .unwrap_err()
             ),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
         assert_eq!(
             discriminant(
                 &deserialize::<Vec<u8>>(&[0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00])
                     .unwrap_err()
             ),
-            discriminant(&ParseError::NonMinimalVarInt.into())
+            discriminant(&ParseError::NonMinimalCompactSize.into())
         );
 
         let mut vec_256 = vec![0; 259];
@@ -924,12 +894,6 @@ mod tests {
         assert!(deserialize::<Vec<u8>>(&vec_253).is_ok());
     }
 
-    #[test]
-    fn serialize_checkeddata() {
-        let cd = CheckedData::new(vec![1u8, 2, 3, 4, 5]);
-        assert_eq!(serialize(&cd), [5, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
-    }
-
     #[test]
     fn serialize_vector() {
         assert_eq!(serialize(&vec![1u8, 2, 3]), [3u8, 1, 2, 3]);
@@ -1036,23 +1000,17 @@ mod tests {
 
         // Check serialization that `if len > MAX_VEC_SIZE {return err}` isn't inclusive,
         // by making sure it fails with `MissingData` and not an `OversizedVectorAllocation` Error.
-        let err =
-            deserialize::<CheckedData>(&serialize(&(super::MAX_VEC_SIZE as u32))).unwrap_err();
-        assert_eq!(err, DeserializeError::Parse(ParseError::MissingData));
+        let err = deserialize::<BlockHash>(&serialize(&(super::MAX_VEC_SIZE as u32))).unwrap_err();
+        assert!(matches!(err, DeserializeError::Parse(ParseError::MissingData)));
 
         test_len_is_max_vec::<u8>();
         test_len_is_max_vec::<BlockHash>();
-        test_len_is_max_vec::<FilterHash>();
         test_len_is_max_vec::<TxMerkleNode>();
         test_len_is_max_vec::<Transaction>();
         test_len_is_max_vec::<TxOut>();
         test_len_is_max_vec::<TxIn>();
         test_len_is_max_vec::<Vec<u8>>();
         test_len_is_max_vec::<u64>();
-        #[cfg(feature = "std")]
-        test_len_is_max_vec::<(u32, Address)>();
-        #[cfg(feature = "std")]
-        test_len_is_max_vec::<Inventory>();
     }
 
     fn test_len_is_max_vec<T>()
@@ -1063,7 +1021,7 @@ mod tests {
         let mut buf = Vec::new();
         buf.emit_compact_size(super::MAX_VEC_SIZE / mem::size_of::<T>()).unwrap();
         let err = deserialize::<Vec<T>>(&buf).unwrap_err();
-        assert_eq!(err, DeserializeError::Parse(ParseError::MissingData));
+        assert!(matches!(err, DeserializeError::Parse(ParseError::MissingData)));
     }
 
     #[test]
@@ -1078,13 +1036,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn deserialize_checkeddata() {
-        let cd: Result<CheckedData, _> =
-            deserialize(&[5u8, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
-        assert_eq!(cd.ok(), Some(CheckedData::new(vec![1u8, 2, 3, 4, 5])));
-    }
-
     #[test]
     fn limit_read() {
         let witness = vec![vec![0u8; 3_999_999]; 2];
@@ -1095,14 +1046,14 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn serialization_round_trips() {
-        use secp256k1::rand::{thread_rng, Rng};
+        use secp256k1::rand::{self, Rng};
 
         macro_rules! round_trip {
             ($($val_type:ty),*) => {
                 $(
-                    let r: $val_type = thread_rng().gen();
+                    let r: $val_type = rand::rng().random();
                     assert_eq!(deserialize::<$val_type>(&serialize(&r)).unwrap(), r);
                 )*
             };
@@ -1110,7 +1061,7 @@ mod tests {
         macro_rules! round_trip_bytes {
             ($(($val_type:ty, $data:expr)),*) => {
                 $(
-                    thread_rng().fill(&mut $data[..]);
+                    rand::rng().fill(&mut $data[..]);
                     assert_eq!(deserialize::<$val_type>(&serialize(&$data)).unwrap()[..], $data[..]);
                 )*
             };
@@ -1125,7 +1076,7 @@ mod tests {
 
             data.clear();
             data64.clear();
-            let len = thread_rng().gen_range(1..256);
+            let len = rand::rng().random_range(1..256);
             data.resize(len, 0u8);
             data64.resize(len, 0u64);
             let mut arr33 = [0u8; 33];
@@ -1167,4 +1118,45 @@ mod tests {
             FromHexError::Decode(DecodeError::Unconsumed)
         ));
     }
+
+    #[test]
+    fn deserialize_extreme_tx() {
+        use crate::{ScriptSigBuf, Witness};
+
+        // Start with transaction from `deserialize_tx_hex`
+        let hex = include_str!("../../tests/data/previous_tx_0_hex"); // An arbitrary transaction.
+        let tx = deserialize_hex::<Transaction>(hex).unwrap();
+
+        assert_eq!(tx.inputs.len(), 1);
+        assert_eq!(tx.outputs.len(), 2);
+        assert_eq!(tx.inputs[0].witness.len(), 2);
+
+        // 1. Test with 4 million witnesses.
+        let mut tx_copy = tx.clone();
+        tx_copy.inputs[0].witness = Witness::from_slice(&vec![vec![]; 4_000_000]);
+        let roundtrip = deserialize(&serialize(&tx_copy)).unwrap();
+        assert_eq!(tx_copy, roundtrip);
+
+        // 2. Test with a single large witness. (Size of 4 megs, including length prefix)
+        let mut tx_copy = tx.clone();
+        tx_copy.inputs[0].witness = Witness::from_slice(&vec![vec![0; 4_000_000 - 9]; 1]);
+        let roundtrip = deserialize(&serialize(&tx_copy)).unwrap();
+        assert_eq!(tx_copy, roundtrip);
+
+        // 3. Combine these; with the witness stack we can exceed a total size of 4M but
+        //    only by a tiny bit. (It is not part of our API guarantee that such things
+        //    will round-trip, but we unit test them anyway to help notice changes.)
+        let mut tx_copy = tx.clone();
+        tx_copy.inputs[0].witness = Witness::from_slice(&vec![vec![0; 997]; 4_000]);
+        let roundtrip = deserialize(&serialize(&tx_copy)).unwrap();
+        assert_eq!(tx_copy, roundtrip);
+
+        // 4. Test with a large script sig. With scriptsigs there is no limit on how large
+        //    an object we can parse, which is inconsistent with witnesses. Also not an
+        //    API guarantee.
+        let mut tx_copy = tx;
+        tx_copy.inputs[0].script_sig = ScriptSigBuf::from(vec![0; 8_000_001]);
+        let roundtrip = deserialize(&serialize(&tx_copy)).unwrap();
+        assert_eq!(tx_copy, roundtrip);
+    }
 }
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index be0bccc9de..d16b1a3f21 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -6,14 +6,13 @@ use core::convert::Infallible;
 use core::fmt;
 
 use hex::error::{InvalidCharError, OddLengthStringError};
-use hex::DisplayHex as _;
 use internals::write_err;
 
 #[cfg(doc)]
 use super::IterReader;
 
 /// Error deserializing from a slice.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
 #[non_exhaustive]
 pub enum DeserializeError {
     /// Error parsing encoded object.
@@ -28,11 +27,9 @@ impl From<Infallible> for DeserializeError {
 
 impl fmt::Display for DeserializeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use DeserializeError::*;
-
-        match *self {
-            Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
-            Unconsumed => write!(f, "data not consumed entirely when deserializing"),
+        match self {
+            Self::Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
+            Self::Unconsumed => write!(f, "data not consumed entirely when deserializing"),
         }
     }
 }
@@ -40,11 +37,9 @@ impl fmt::Display for DeserializeError {
 #[cfg(feature = "std")]
 impl std::error::Error for DeserializeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use DeserializeError::*;
-
-        match *self {
-            Parse(ref e) => Some(e),
-            Unconsumed => None,
+        match self {
+            Self::Parse(ref e) => Some(e),
+            Self::Unconsumed => None,
         }
     }
 }
@@ -55,7 +50,7 @@ impl From<ParseError> for DeserializeError {
 
 /// Error when consensus decoding from an `[IterReader]`.
 ///
-/// This is the same as a `DeserializeError` with an additional variant to return any error yealded
+/// This is the same as a `DeserializeError` with an additional variant to return any error yielded
 /// by the inner bytes iterator.
 #[derive(Debug)]
 pub enum DecodeError<E> {
@@ -73,12 +68,10 @@ impl<E> From<Infallible> for DecodeError<E> {
 
 impl<E: fmt::Debug> fmt::Display for DecodeError<E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use DecodeError::*;
-
-        match *self {
-            Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
-            Unconsumed => write!(f, "data not consumed entirely when deserializing"),
-            Other(ref other) => write!(f, "other decoding error: {:?}", other),
+        match self {
+            Self::Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
+            Self::Unconsumed => write!(f, "data not consumed entirely when deserializing"),
+            Self::Other(ref other) => write!(f, "other decoding error: {:?}", other),
         }
     }
 }
@@ -86,12 +79,10 @@ impl<E: fmt::Debug> fmt::Display for DecodeError<E> {
 #[cfg(feature = "std")]
 impl<E: fmt::Debug + std::error::Error + 'static> std::error::Error for DecodeError<E> {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use DecodeError::*;
-
-        match *self {
-            Parse(ref e) => Some(e),
-            Unconsumed => None,
-            Other(ref e) => Some(e),
+        match self {
+            Self::Parse(ref e) => Some(e),
+            Self::Unconsumed => None,
+            Self::Other(ref e) => Some(e),
         }
     }
 }
@@ -100,7 +91,7 @@ impl<E: fmt::Debug + std::error::Error + 'static> std::error::Error for DecodeEr
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum Error {
-    /// And I/O error.
+    /// An I/O error.
     Io(io::Error),
     /// Error parsing encoded object.
     Parse(ParseError),
@@ -112,11 +103,9 @@ impl From<Infallible> for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Error::*;
-
-        match *self {
-            Io(ref e) => write_err!(f, "I/O error"; e),
-            Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
+        match self {
+            Self::Io(ref e) => write_err!(f, "I/O error"; e),
+            Self::Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
         }
     }
 }
@@ -124,11 +113,9 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Error::*;
-
-        match *self {
-            Io(ref e) => Some(e),
-            Parse(ref e) => Some(e),
+        match self {
+            Self::Io(ref e) => Some(e),
+            Self::Parse(ref e) => Some(e),
         }
     }
 }
@@ -138,18 +125,18 @@ impl From<io::Error> for Error {
         use io::ErrorKind;
 
         match e.kind() {
-            ErrorKind::UnexpectedEof => Error::Parse(ParseError::MissingData),
-            _ => Error::Io(e),
+            ErrorKind::UnexpectedEof => Self::Parse(ParseError::MissingData),
+            _ => Self::Io(e),
         }
     }
 }
 
 impl From<ParseError> for Error {
-    fn from(e: ParseError) -> Self { Error::Parse(e) }
+    fn from(e: ParseError) -> Self { Self::Parse(e) }
 }
 
 /// Encoding is invalid.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
 #[non_exhaustive]
 pub enum ParseError {
     /// Missing data (early end of file or slice too short).
@@ -168,12 +155,14 @@ pub enum ParseError {
         /// The invalid checksum.
         actual: [u8; 4],
     },
-    /// VarInt was encoded in a non-minimal way.
-    NonMinimalVarInt,
+    /// CompactSize was encoded in a non-minimal way.
+    NonMinimalCompactSize,
     /// Parsing error.
     ParseFailed(&'static str),
     /// Unsupported SegWit flag.
     UnsupportedSegwitFlag(u8),
+    /// Witness decoding error.
+    Witness(io::ReadError<primitives::witness::WitnessDecoderError>),
 }
 
 impl From<Infallible> for ParseError {
@@ -182,18 +171,20 @@ impl From<Infallible> for ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseError::*;
-
-        match *self {
-            MissingData => write!(f, "missing data (early end of file or slice too short)"),
-            OversizedVectorAllocation { requested: ref r, max: ref m } =>
+        match self {
+            Self::MissingData => write!(f, "missing data (early end of file or slice too short)"),
+            Self::OversizedVectorAllocation { requested: ref r, max: ref m } =>
                 write!(f, "allocation of oversized vector: requested {}, maximum {}", r, m),
-            InvalidChecksum { expected: ref e, actual: ref a } =>
-                write!(f, "invalid checksum: expected {:x}, actual {:x}", e.as_hex(), a.as_hex()),
-            NonMinimalVarInt => write!(f, "non-minimal varint"),
-            ParseFailed(ref s) => write!(f, "parse failed: {}", s),
-            UnsupportedSegwitFlag(ref swflag) =>
+            Self::InvalidChecksum { expected: ref e, actual: ref a } => write!(
+                f,
+                "invalid checksum: expected {:02x}{:02x}{:02x}{:02x}, actual {:02x}{:02x}{:02x}{:02x}",
+                e[0], e[1], e[2], e[3], a[0], a[1], a[2], a[3],
+            ),
+            Self::NonMinimalCompactSize => write!(f, "non-minimal compact size"),
+            Self::ParseFailed(ref s) => write!(f, "parse failed: {}", s),
+            Self::UnsupportedSegwitFlag(ref swflag) =>
                 write!(f, "unsupported SegWit version: {}", swflag),
+            Self::Witness(ref e) => write_err!(f, "witness"; e),
         }
     }
 }
@@ -201,15 +192,14 @@ impl fmt::Display for ParseError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseError::*;
-
         match self {
-            MissingData
-            | OversizedVectorAllocation { .. }
-            | InvalidChecksum { .. }
-            | NonMinimalVarInt
-            | ParseFailed(_)
-            | UnsupportedSegwitFlag(_) => None,
+            Self::Witness(ref e) => Some(e),
+            Self::MissingData
+            | Self::OversizedVectorAllocation { .. }
+            | Self::InvalidChecksum { .. }
+            | Self::NonMinimalCompactSize
+            | Self::ParseFailed(_)
+            | Self::UnsupportedSegwitFlag(_) => None,
         }
     }
 }
@@ -225,12 +215,10 @@ pub enum FromHexError {
 
 impl fmt::Display for FromHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use FromHexError::*;
-
-        match *self {
-            OddLengthString(ref e) =>
+        match self {
+            Self::OddLengthString(ref e) =>
                 write_err!(f, "odd length, failed to create bytes from hex"; e),
-            Decode(ref e) => write_err!(f, "decoding error"; e),
+            Self::Decode(ref e) => write_err!(f, "decoding error"; e),
         }
     }
 }
@@ -238,11 +226,9 @@ impl fmt::Display for FromHexError {
 #[cfg(feature = "std")]
 impl std::error::Error for FromHexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use FromHexError::*;
-
-        match *self {
-            OddLengthString(ref e) => Some(e),
-            Decode(ref e) => Some(e),
+        match self {
+            Self::OddLengthString(ref e) => Some(e),
+            Self::Decode(ref e) => Some(e),
         }
     }
 }
@@ -257,3 +243,44 @@ impl From<OddLengthStringError> for FromHexError {
 pub(crate) fn parse_failed_error(msg: &'static str) -> Error {
     Error::Parse(ParseError::ParseFailed(msg))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn invalid_checksum_display() {
+        let e = ParseError::InvalidChecksum {
+            expected: [0xde, 0xad, 0xbe, 0xef],
+            actual: [0xca, 0xfe, 0xba, 0xbe],
+        };
+
+        let want = "invalid checksum: expected deadbeef, actual cafebabe";
+        let got = format!("{}", e);
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn invalid_checksum_display_expected_leading_zeros() {
+        let e = ParseError::InvalidChecksum {
+            expected: [0x00, 0x00, 0x00, 0x0f],
+            actual: [0xca, 0xfe, 0xba, 0xbe],
+        };
+
+        let want = "invalid checksum: expected 0000000f, actual cafebabe";
+        let got = format!("{}", e);
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn invalid_checksum_display_actual_leading_zeros() {
+        let e = ParseError::InvalidChecksum {
+            expected: [0xde, 0xad, 0xbe, 0xef],
+            actual: [0x00, 0x00, 0x00, 0x0e],
+        };
+
+        let want = "invalid checksum: expected deadbeef, actual 0000000e";
+        let got = format!("{}", e);
+        assert_eq!(got, want);
+    }
+}
diff --git a/bitcoin/src/consensus/mod.rs b/bitcoin/src/consensus/mod.rs
index ecf4b6fdb0..dbfa9c4d6c 100644
--- a/bitcoin/src/consensus/mod.rs
+++ b/bitcoin/src/consensus/mod.rs
@@ -32,7 +32,7 @@ struct IterReader<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> {
 
 impl<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> IterReader<E, I> {
     pub(crate) fn new(iterator: I) -> Self {
-        IterReader { iterator: iterator.fuse(), buf: None, error: None }
+        Self { iterator: iterator.fuse(), buf: None, error: None }
     }
 
     fn decode<T: Decodable>(mut self) -> Result<T, DecodeError<E>> {
diff --git a/bitcoin/src/consensus/serde.rs b/bitcoin/src/consensus/serde.rs
index a182e8640f..79a3e7d722 100644
--- a/bitcoin/src/consensus/serde.rs
+++ b/bitcoin/src/consensus/serde.rs
@@ -26,7 +26,7 @@ where
     Case: hex::Case;
 
 impl<C: hex::Case> Default for Hex<C> {
-    fn default() -> Self { Hex(Default::default()) }
+    fn default() -> Self { Self(Default::default()) }
 }
 
 impl<C: hex::Case> ByteEncoder for Hex<C> {
@@ -75,7 +75,7 @@ pub mod hex {
 
     impl<C: Case> From<super::Hex<C>> for Encoder<C> {
         fn from(_: super::Hex<C>) -> Self {
-            Encoder(BufEncoder::new(C::INTERNAL_CASE), Default::default())
+            Self(BufEncoder::new(C::INTERNAL_CASE), Default::default())
         }
     }
 
@@ -194,7 +194,7 @@ struct ErrorTrackingWriter<W: fmt::Write> {
 
 impl<W: fmt::Write> ErrorTrackingWriter<W> {
     fn new(writer: W) -> Self {
-        ErrorTrackingWriter {
+        Self {
             writer,
             #[cfg(debug_assertions)]
             was_error: false,
@@ -373,11 +373,12 @@ fn consensus_error_into_serde<E: serde::de::Error>(error: ParseError) -> E {
                 expected[0], expected[1], expected[2], expected[3]
             )),
         ),
-        ParseError::NonMinimalVarInt =>
+        ParseError::NonMinimalCompactSize =>
             E::custom(format_args!("compact size was not encoded minimally")),
         ParseError::ParseFailed(msg) => E::custom(msg),
         ParseError::UnsupportedSegwitFlag(flag) =>
             E::invalid_value(Unexpected::Unsigned(flag.into()), &"segwit version 1 flag"),
+        ParseError::Witness(e) => E::custom(e),
     }
 }
 
@@ -387,9 +388,9 @@ where
 {
     fn unify(self) -> E {
         match self {
-            DecodeError::Other(error) => error,
-            DecodeError::Unconsumed => E::custom(format_args!("got more bytes than expected")),
-            DecodeError::Parse(e) => consensus_error_into_serde(e),
+            Self::Other(error) => error,
+            Self::Unconsumed => E::custom(format_args!("got more bytes than expected")),
+            Self::Parse(e) => consensus_error_into_serde(e),
         }
     }
 }
@@ -400,9 +401,9 @@ where
 {
     fn into_de_error<DE: serde::de::Error>(self) -> DE {
         match self {
-            DecodeError::Other(error) => error.into_de_error(),
-            DecodeError::Unconsumed => DE::custom(format_args!("got more bytes than expected")),
-            DecodeError::Parse(e) => consensus_error_into_serde(e),
+            Self::Other(error) => error.into_de_error(),
+            Self::Unconsumed => DE::custom(format_args!("got more bytes than expected")),
+            Self::Parse(e) => consensus_error_into_serde(e),
         }
     }
 }
diff --git a/bitcoin/src/consensus_validation.rs b/bitcoin/src/consensus_validation.rs
index e80994f905..a998e60244 100644
--- a/bitcoin/src/consensus_validation.rs
+++ b/bitcoin/src/consensus_validation.rs
@@ -14,7 +14,7 @@ use crate::consensus::encode;
 #[cfg(doc)]
 use crate::consensus_validation;
 use crate::internal_macros::define_extension_trait;
-use crate::script::Script;
+use crate::script::ScriptPubKey;
 use crate::transaction::{OutPoint, Transaction, TxOut};
 
 /// Verifies spend of an input script.
@@ -24,13 +24,13 @@ use crate::transaction::{OutPoint, Transaction, TxOut};
 ///
 /// # Parameters
 ///
-///  * `index` - The input index in spending which is spending this transaction.
-///  * `amount` - The amount this script guards.
-///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+///  * `index` - the input index in spending which is spending this transaction.
+///  * `amount` - the amount this script guards.
+///  * `spending_tx` - the transaction that attempts to spend the output holding this script.
 ///
 /// [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`]: https://docs.rs/bitcoinconsensus/0.106.0+26.0/bitcoinconsensus/constant.VERIFY_ALL_PRE_TAPROOT.html
 pub fn verify_script(
-    script: &Script,
+    script: &ScriptPubKey,
     index: usize,
     amount: Amount,
     spending_tx: &[u8],
@@ -48,14 +48,14 @@ pub fn verify_script(
 ///
 /// # Parameters
 ///
-///  * `index` - The input index in spending which is spending this transaction.
-///  * `amount` - The amount this script guards.
-///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
-///  * `flags` - Verification flags, see [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`] and similar.
+///  * `index` - the input index in spending which is spending this transaction.
+///  * `amount` - the amount this script guards.
+///  * `spending_tx` - the transaction that attempts to spend the output holding this script.
+///  * `flags` - the verification flags, see [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`] and similar.
 ///
 /// [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`]: https://docs.rs/bitcoinconsensus/0.106.0+26.0/bitcoinconsensus/constant.VERIFY_ALL_PRE_TAPROOT.html
 pub fn verify_script_with_flags<F: Into<u32>>(
-    script: &Script,
+    script: &ScriptPubKey,
     index: usize,
     amount: Amount,
     spending_tx: &[u8],
@@ -101,12 +101,12 @@ where
 {
     let serialized_tx = encode::serialize(tx);
     let flags: u32 = flags.into();
-    for (idx, input) in tx.input.iter().enumerate() {
+    for (idx, input) in tx.inputs.iter().enumerate() {
         if let Some(output) = spent(&input.previous_output) {
             verify_script_with_flags(
                 &output.script_pubkey,
                 idx,
-                output.value,
+                output.amount,
                 serialized_tx.as_slice(),
                 flags,
             )?;
@@ -118,17 +118,17 @@ where
 }
 
 define_extension_trait! {
-    /// Extension functionality to add validation support to the [`Script`] type.
-    pub trait ScriptExt impl for Script {
+    /// Extension functionality to add validation support to the [`ScriptPubKey`] type.
+    pub trait ScriptPubKeyExt impl for ScriptPubKey {
         /// Verifies spend of an input script.
         ///
         /// Shorthand for [`Self::verify_with_flags`] with flag [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`].
         ///
         /// # Parameters
         ///
-        ///  * `index` - The input index in spending which is spending this transaction.
-        ///  * `amount` - The amount this script guards.
-        ///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+        ///  * `index` - the input index in spending which is spending this transaction.
+        ///  * `amount` - the amount this script guards.
+        ///  * `spending_tx` - the transaction that attempts to spend the output holding this script.
         ///
         /// [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`]: https://docs.rs/bitcoinconsensus/0.106.0+26.0/bitcoinconsensus/constant.VERIFY_ALL_PRE_TAPROOT.html
         fn verify(
@@ -144,10 +144,10 @@ define_extension_trait! {
         ///
         /// # Parameters
         ///
-        ///  * `index` - The input index in spending which is spending this transaction.
-        ///  * `amount` - The amount this script guards.
-        ///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
-        ///  * `flags` - Verification flags, see [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`] and similar.
+        ///  * `index` - the input index in spending which is spending this transaction.
+        ///  * `amount` - the amount this script guards.
+        ///  * `spending_tx` - the transaction that attempts to spend the output holding this script.
+        ///  * `flags` - the verification flags, see [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`] and similar.
         ///
         /// [`bitcoinconsensus::VERIFY_ALL_PRE_TAPROOT`]: https://docs.rs/bitcoinconsensus/0.106.0+26.0/bitcoinconsensus/constant.VERIFY_ALL_PRE_TAPROOT.html
         fn verify_with_flags(
@@ -203,7 +203,7 @@ impl TransactionExt for Transaction {
 
 mod sealed {
     pub trait Sealed {}
-    impl Sealed for super::Script {}
+    impl Sealed for super::ScriptPubKey {}
     impl Sealed for super::Transaction {}
 }
 
@@ -244,11 +244,10 @@ impl From<Infallible> for TxVerifyError {
 
 impl fmt::Display for TxVerifyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use TxVerifyError::*;
-
-        match *self {
-            ScriptVerification(ref e) => write_err!(f, "bitcoinconsensus verification failed"; e),
-            UnknownSpentOutput(ref p) => write!(f, "unknown spent output: {}", p),
+        match self {
+            Self::ScriptVerification(ref e) =>
+                write_err!(f, "bitcoinconsensus verification failed"; e),
+            Self::UnknownSpentOutput(ref p) => write!(f, "unknown spent output: {}", p),
         }
     }
 }
@@ -256,15 +255,13 @@ impl fmt::Display for TxVerifyError {
 #[cfg(feature = "std")]
 impl std::error::Error for TxVerifyError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use TxVerifyError::*;
-
-        match *self {
-            ScriptVerification(ref e) => Some(e),
-            UnknownSpentOutput(_) => None,
+        match self {
+            Self::ScriptVerification(ref e) => Some(e),
+            Self::UnknownSpentOutput(_) => None,
         }
     }
 }
 
 impl From<BitcoinconsensusError> for TxVerifyError {
-    fn from(e: BitcoinconsensusError) -> Self { TxVerifyError::ScriptVerification(e) }
+    fn from(e: BitcoinconsensusError) -> Self { Self::ScriptVerification(e) }
 }
diff --git a/bitcoin/src/crypto/ecdsa.rs b/bitcoin/src/crypto/ecdsa.rs
index 58c0b028b4..feec355206 100644
--- a/bitcoin/src/crypto/ecdsa.rs
+++ b/bitcoin/src/crypto/ecdsa.rs
@@ -4,7 +4,9 @@
 //!
 //! This module provides ECDSA signatures used by Bitcoin that can be roundtrip (de)serialized.
 
+use core::borrow::Borrow;
 use core::convert::Infallible;
+use core::ops::Deref;
 use core::str::FromStr;
 use core::{fmt, iter};
 
@@ -15,9 +17,8 @@ use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::Write;
 
 use crate::prelude::{DisplayHex, Vec};
-use crate::script::PushBytes;
 #[cfg(doc)]
-use crate::script::ScriptBufExt as _;
+use crate::script::ScriptPubKeyBufExt as _;
 use crate::sighash::{EcdsaSighashType, NonStandardSighashTypeError};
 
 const MAX_SIG_LEN: usize = 73;
@@ -34,8 +35,8 @@ pub struct Signature {
 
 impl Signature {
     /// Constructs a new ECDSA Bitcoin signature for [`EcdsaSighashType::All`].
-    pub fn sighash_all(signature: secp256k1::ecdsa::Signature) -> Signature {
-        Signature { signature, sighash_type: EcdsaSighashType::All }
+    pub fn sighash_all(signature: secp256k1::ecdsa::Signature) -> Self {
+        Self { signature, sighash_type: EcdsaSighashType::All }
     }
 
     /// Deserializes from slice following the standardness rules for [`EcdsaSighashType`].
@@ -44,7 +45,7 @@ impl Signature {
         let sighash_type = EcdsaSighashType::from_standard(*sighash_type as u32)?;
         let signature =
             secp256k1::ecdsa::Signature::from_der(sig).map_err(DecodeError::Secp256k1)?;
-        Ok(Signature { signature, sighash_type })
+        Ok(Self { signature, sighash_type })
     }
 
     /// Serializes an ECDSA signature (inner secp256k1 signature in DER format).
@@ -100,8 +101,9 @@ impl FromStr for Signature {
 /// This avoids allocation and allows proving maximum size of the signature (73 bytes).
 /// The type can be used largely as a byte slice. It implements all standard traits one would
 /// expect and has familiar methods.
+///
 /// However, the usual use case is to push it into a script. This can be done directly passing it
-/// into [`push_slice`](crate::script::ScriptBuf::push_slice).
+/// into [`push_slice`](crate::script::ScriptBufExt::push_slice).
 #[derive(Copy, Clone)]
 pub struct SerializedSignature {
     data: [u8; MAX_SIG_LEN],
@@ -109,6 +111,24 @@ pub struct SerializedSignature {
 }
 
 impl SerializedSignature {
+    /// Constructs a new SerializedSignature from a Signature.
+    ///
+    /// In other words this serializes a `Signature` into a `SerializedSignature`.
+    #[inline]
+    pub fn from_signature(sig: Signature) -> Self { sig.serialize() }
+
+    /// Converts the serialized signature into the [`Signature`] struct.
+    ///
+    /// In other words this deserializes the `SerializedSignature`.
+    #[inline]
+    pub fn to_signature(self) -> Result<Signature, DecodeError> { Signature::from_slice(&self) }
+
+    /// Returns the length of the serialized signature data.
+    #[inline]
+    // `len` is never 0, so `is_empty` would always return `false`.
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize { self.len }
+
     /// Returns an iterator over bytes of the signature.
     #[inline]
     pub fn iter(&self) -> core::slice::Iter<'_, u8> { self.into_iter() }
@@ -120,86 +140,96 @@ impl SerializedSignature {
     }
 }
 
-impl core::ops::Deref for SerializedSignature {
-    type Target = [u8];
-
+impl fmt::Debug for SerializedSignature {
     #[inline]
-    fn deref(&self) -> &Self::Target { &self.data[..self.len] }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self, f) }
 }
 
-impl core::ops::DerefMut for SerializedSignature {
+impl fmt::Display for SerializedSignature {
     #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.data[..self.len] }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self, f) }
 }
 
-impl AsRef<[u8]> for SerializedSignature {
+impl fmt::LowerHex for SerializedSignature {
     #[inline]
-    fn as_ref(&self) -> &[u8] { self }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&(**self).as_hex(), f)
+    }
 }
+impl_to_hex_from_lower_hex!(SerializedSignature, |signature: &SerializedSignature| signature.len
+    * 2);
 
-impl AsMut<[u8]> for SerializedSignature {
+impl fmt::UpperHex for SerializedSignature {
     #[inline]
-    fn as_mut(&mut self) -> &mut [u8] { self }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&(**self).as_hex(), f)
+    }
 }
 
-impl AsRef<PushBytes> for SerializedSignature {
+impl PartialEq for SerializedSignature {
     #[inline]
-    fn as_ref(&self) -> &PushBytes { &<&PushBytes>::from(&self.data)[..self.len()] }
+    fn eq(&self, other: &Self) -> bool { **self == **other }
 }
 
-impl core::borrow::Borrow<[u8]> for SerializedSignature {
+impl PartialEq<[u8]> for SerializedSignature {
     #[inline]
-    fn borrow(&self) -> &[u8] { self }
+    fn eq(&self, other: &[u8]) -> bool { **self == *other }
 }
 
-impl core::borrow::BorrowMut<[u8]> for SerializedSignature {
+impl PartialEq<SerializedSignature> for [u8] {
     #[inline]
-    fn borrow_mut(&mut self) -> &mut [u8] { self }
+    fn eq(&self, other: &SerializedSignature) -> bool { *self == **other }
 }
 
-impl fmt::Debug for SerializedSignature {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self, f) }
+impl PartialOrd for SerializedSignature {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { Some(self.cmp(other)) }
 }
 
-impl fmt::Display for SerializedSignature {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self, f) }
+impl Ord for SerializedSignature {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering { (**self).cmp(&**other) }
 }
 
-impl fmt::LowerHex for SerializedSignature {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::LowerHex::fmt(&(**self).as_hex(), f)
+impl PartialOrd<[u8]> for SerializedSignature {
+    fn partial_cmp(&self, other: &[u8]) -> Option<core::cmp::Ordering> {
+        (**self).partial_cmp(other)
     }
 }
-impl_to_hex_from_lower_hex!(SerializedSignature, |signature: &SerializedSignature| signature.len
-    * 2);
 
-impl fmt::UpperHex for SerializedSignature {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::UpperHex::fmt(&(**self).as_hex(), f)
+impl PartialOrd<SerializedSignature> for [u8] {
+    fn partial_cmp(&self, other: &SerializedSignature) -> Option<core::cmp::Ordering> {
+        self.partial_cmp(&**other)
     }
 }
 
-impl PartialEq for SerializedSignature {
-    #[inline]
-    fn eq(&self, other: &SerializedSignature) -> bool { **self == **other }
-}
-
 impl Eq for SerializedSignature {}
 
 impl core::hash::Hash for SerializedSignature {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) { core::hash::Hash::hash(&**self, state) }
 }
 
+impl AsRef<[u8]> for SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &[u8] { &self.data[..self.len] }
+}
+
+impl Borrow<[u8]> for SerializedSignature {
+    #[inline]
+    fn borrow(&self) -> &[u8] { &self.data[..self.len] }
+}
+
+impl Deref for SerializedSignature {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target { &self.data[..self.len] }
+}
+
 impl<'a> IntoIterator for &'a SerializedSignature {
     type IntoIter = core::slice::Iter<'a, u8>;
     type Item = &'a u8;
 
     #[inline]
-    fn into_iter(self) -> Self::IntoIter { (*self).iter() }
+    fn into_iter(self) -> Self::IntoIter { (**self).iter() }
 }
 
 /// Error encountered while parsing an ECDSA signature from a byte slice.
@@ -220,12 +250,10 @@ impl From<Infallible> for DecodeError {
 
 impl fmt::Display for DecodeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use DecodeError::*;
-
-        match *self {
-            SighashType(ref e) => write_err!(f, "non-standard signature hash type"; e),
-            EmptySignature => write!(f, "empty ECDSA signature"),
-            Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
+        match self {
+            Self::SighashType(ref e) => write_err!(f, "non-standard signature hash type"; e),
+            Self::EmptySignature => write!(f, "empty ECDSA signature"),
+            Self::Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
         }
     }
 }
@@ -233,12 +261,10 @@ impl fmt::Display for DecodeError {
 #[cfg(feature = "std")]
 impl std::error::Error for DecodeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use DecodeError::*;
-
-        match *self {
-            Secp256k1(ref e) => Some(e),
-            SighashType(ref e) => Some(e),
-            EmptySignature => None,
+        match self {
+            Self::Secp256k1(ref e) => Some(e),
+            Self::SighashType(ref e) => Some(e),
+            Self::EmptySignature => None,
         }
     }
 }
@@ -267,11 +293,9 @@ impl From<Infallible> for ParseSignatureError {
 
 impl fmt::Display for ParseSignatureError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseSignatureError::*;
-
-        match *self {
-            Hex(ref e) => write_err!(f, "signature hex decoding error"; e),
-            Decode(ref e) => write_err!(f, "signature byte slice decoding error"; e),
+        match self {
+            Self::Hex(ref e) => write_err!(f, "signature hex decoding error"; e),
+            Self::Decode(ref e) => write_err!(f, "signature byte slice decoding error"; e),
         }
     }
 }
@@ -279,11 +303,9 @@ impl fmt::Display for ParseSignatureError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseSignatureError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseSignatureError::*;
-
-        match *self {
-            Hex(ref e) => Some(e),
-            Decode(ref e) => Some(e),
+        match self {
+            Self::Hex(ref e) => Some(e),
+            Self::Decode(ref e) => Some(e),
         }
     }
 }
@@ -324,7 +346,7 @@ impl<'a> Arbitrary<'a> for Signature {
         signature_bytes[..32].copy_from_slice(&bytes);
         signature_bytes[32..].copy_from_slice(&bytes);
 
-        Ok(Signature {
+        Ok(Self {
             signature: secp256k1::ecdsa::Signature::from_compact(&signature_bytes).unwrap(),
             sighash_type: EcdsaSighashType::arbitrary(u)?,
         })
@@ -335,11 +357,12 @@ impl<'a> Arbitrary<'a> for Signature {
 mod tests {
     use super::*;
 
+    const TEST_SIGNATURE_HEX: &str = "3046022100839c1fbc5304de944f697c9f4b1d01d1faeba32d751c0f7acb21ac8a0f436a72022100e89bd46bb3a5a62adc679f659b7ce876d83ee297c7a5587b2011c4fcc72eab45";
+
     #[test]
     fn write_serialized_signature() {
-        let hex = "3046022100839c1fbc5304de944f697c9f4b1d01d1faeba32d751c0f7acb21ac8a0f436a72022100e89bd46bb3a5a62adc679f659b7ce876d83ee297c7a5587b2011c4fcc72eab45";
         let sig = Signature {
-            signature: secp256k1::ecdsa::Signature::from_str(hex).unwrap(),
+            signature: secp256k1::ecdsa::Signature::from_str(TEST_SIGNATURE_HEX).unwrap(),
             sighash_type: EcdsaSighashType::All,
         };
 
@@ -348,4 +371,14 @@ mod tests {
 
         assert_eq!(sig.to_vec(), buf)
     }
+
+    #[test]
+    fn iterate_serialized_signature() {
+        let sig = Signature {
+            signature: secp256k1::ecdsa::Signature::from_str(TEST_SIGNATURE_HEX).unwrap(),
+            sighash_type: EcdsaSighashType::All,
+        };
+
+        assert_eq!(sig.serialize().iter().copied().collect::<Vec<u8>>(), sig.to_vec());
+    }
 }
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index b20c76a09a..65ac68db75 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -21,47 +21,49 @@ use crate::crypto::ecdsa;
 use crate::internal_macros::impl_asref_push_bytes;
 use crate::network::NetworkKind;
 use crate::prelude::{DisplayHex, String, Vec};
-use crate::script::{self, ScriptBuf};
+use crate::script::{self, WitnessScriptBuf};
 use crate::taproot::{TapNodeHash, TapTweakHash};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
-pub use secp256k1::{constants, Keypair, Parity, Secp256k1, Verification};
-#[cfg(feature = "rand-std")]
+pub use secp256k1::{constants, Keypair, Parity, Verification};
+#[cfg(all(feature = "rand", feature = "std"))]
 pub use secp256k1::rand;
 pub use serialized_x_only::SerializedXOnlyPublicKey;
 
-/// A Bitcoin Schnorr X-only public key used for BIP340 signatures.
+/// A Bitcoin Schnorr X-only public key used for BIP-0340 signatures.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct XOnlyPublicKey(secp256k1::XOnlyPublicKey);
 
 impl XOnlyPublicKey {
-    /// Constructs a new x-only public key from the provided generic Secp256k1 x-only public key.
-    pub fn new(key: impl Into<secp256k1::XOnlyPublicKey>) -> XOnlyPublicKey {
-        XOnlyPublicKey(key.into())
-    }
+    /// Constructs a new x-only public key from the provided generic secp256k1 x-only public key.
+    pub fn new(key: impl Into<secp256k1::XOnlyPublicKey>) -> Self { Self(key.into()) }
 
-    /// Creates an x-only public key from a keypair.
+    /// Constructs an x-only public key from a keypair.
     ///
     /// Returns the x-only public key and the parity of the full public key.
     #[inline]
-    pub fn from_keypair(keypair: &Keypair) -> (XOnlyPublicKey, Parity) {
+    pub fn from_keypair(keypair: &Keypair) -> (Self, Parity) {
         let (xonly, parity) = secp256k1::XOnlyPublicKey::from_keypair(keypair);
-        (XOnlyPublicKey::new(xonly), parity)
+        (Self::new(xonly), parity)
     }
 
-    /// Creates an x-only public key from a 32-byte x-coordinate.
+    /// Constructs an x-only public key from a 32-byte x-coordinate.
     ///
     /// Returns an error if the provided bytes don't represent a valid secp256k1 point x-coordinate.
     #[inline]
     pub fn from_byte_array(
         data: &[u8; constants::SCHNORR_PUBLIC_KEY_SIZE],
-    ) -> Result<XOnlyPublicKey, ParseXOnlyPublicKeyError> {
-        secp256k1::XOnlyPublicKey::from_byte_array(data)
-            .map(XOnlyPublicKey::new)
+    ) -> Result<Self, ParseXOnlyPublicKeyError> {
+        secp256k1::XOnlyPublicKey::from_byte_array(*data)
+            .map(Self::new)
             .map_err(|_| ParseXOnlyPublicKeyError::InvalidXCoordinate)
     }
 
+    /// Returns the inner secp256k1 x-only public key.
+    #[inline]
+    pub fn into_inner(self) -> secp256k1::XOnlyPublicKey { self.0 }
+
     /// Serializes the x-only public key as a byte-encoded x coordinate value (32 bytes).
     #[inline]
     pub fn serialize(&self) -> [u8; constants::SCHNORR_PUBLIC_KEY_SIZE] { self.0.serialize() }
@@ -75,14 +77,13 @@ impl XOnlyPublicKey {
     /// Should be called on the original untweaked key. Takes the tweaked key and output parity from
     /// [`XOnlyPublicKey::add_tweak`] as input.
     #[inline]
-    pub fn tweak_add_check<V: Verification>(
+    pub fn tweak_add_check(
         &self,
-        secp: &Secp256k1<V>,
         tweaked_key: &Self,
         tweaked_parity: Parity,
         tweak: secp256k1::Scalar,
     ) -> bool {
-        self.0.tweak_add_check(secp, &tweaked_key.0, tweaked_parity, tweak)
+        self.0.tweak_add_check(&tweaked_key.0, tweaked_parity, tweak)
     }
 
     /// Tweaks an [`XOnlyPublicKey`] by adding the generator multiplied with the given tweak to it.
@@ -97,13 +98,12 @@ impl XOnlyPublicKey {
     ///
     /// If the resulting key would be invalid.
     #[inline]
-    pub fn add_tweak<V: Verification>(
+    pub fn add_tweak(
         &self,
-        secp: &Secp256k1<V>,
         tweak: &secp256k1::Scalar,
-    ) -> Result<(XOnlyPublicKey, Parity), TweakXOnlyPublicKeyError> {
-        match self.0.add_tweak(secp, tweak) {
-            Ok((xonly, parity)) => Ok((XOnlyPublicKey(xonly), parity)),
+    ) -> Result<(Self, Parity), TweakXOnlyPublicKeyError> {
+        match self.0.add_tweak(tweak) {
+            Ok((xonly, parity)) => Ok((Self(xonly), parity)),
             Err(secp256k1::Error::InvalidTweak) => Err(TweakXOnlyPublicKeyError::BadTweak),
             Err(secp256k1::Error::InvalidParityValue(_)) =>
                 Err(TweakXOnlyPublicKeyError::ParityError),
@@ -114,19 +114,19 @@ impl XOnlyPublicKey {
 
 impl FromStr for XOnlyPublicKey {
     type Err = ParseXOnlyPublicKeyError;
-    fn from_str(s: &str) -> Result<XOnlyPublicKey, ParseXOnlyPublicKeyError> {
+    fn from_str(s: &str) -> Result<Self, ParseXOnlyPublicKeyError> {
         secp256k1::XOnlyPublicKey::from_str(s)
-            .map(XOnlyPublicKey::from)
+            .map(Self::from)
             .map_err(|_| ParseXOnlyPublicKeyError::InvalidXCoordinate)
     }
 }
 
 impl From<secp256k1::XOnlyPublicKey> for XOnlyPublicKey {
-    fn from(pk: secp256k1::XOnlyPublicKey) -> XOnlyPublicKey { XOnlyPublicKey::new(pk) }
+    fn from(pk: secp256k1::XOnlyPublicKey) -> Self { Self::new(pk) }
 }
 
 impl From<secp256k1::PublicKey> for XOnlyPublicKey {
-    fn from(pk: secp256k1::PublicKey) -> XOnlyPublicKey { XOnlyPublicKey::new(pk) }
+    fn from(pk: secp256k1::PublicKey) -> Self { Self::new(pk) }
 }
 
 impl fmt::LowerHex for XOnlyPublicKey {
@@ -149,15 +149,15 @@ pub struct PublicKey {
 }
 
 impl PublicKey {
-    /// Constructs a new compressed ECDSA public key from the provided generic Secp256k1 public key.
-    pub fn new(key: impl Into<secp256k1::PublicKey>) -> PublicKey {
-        PublicKey { compressed: true, inner: key.into() }
+    /// Constructs a new compressed ECDSA public key from the provided generic secp256k1 public key.
+    pub fn new(key: impl Into<secp256k1::PublicKey>) -> Self {
+        Self { compressed: true, inner: key.into() }
     }
 
-    /// Constructs a new uncompressed (legacy) ECDSA public key from the provided generic Secp256k1
+    /// Constructs a new uncompressed (legacy) ECDSA public key from the provided generic secp256k1
     /// public key.
-    pub fn new_uncompressed(key: impl Into<secp256k1::PublicKey>) -> PublicKey {
-        PublicKey { compressed: false, inner: key.into() }
+    pub fn new_uncompressed(key: impl Into<secp256k1::PublicKey>) -> Self {
+        Self { compressed: false, inner: key.into() }
     }
 
     fn with_serialized<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
@@ -185,7 +185,11 @@ impl PublicKey {
     }
 
     /// Returns the script code used to spend a P2WPKH input.
-    pub fn p2wpkh_script_code(&self) -> Result<ScriptBuf, UncompressedPublicKeyError> {
+    ///
+    /// While the type returned is [`WitnessScriptBuf`], this is **not** a witness script and
+    /// should not be used as one. It is a special template defined in BIP 143 which is used
+    /// in place of a witness script for purposes of sighash computation.
+    pub fn p2wpkh_script_code(&self) -> Result<WitnessScriptBuf, UncompressedPublicKeyError> {
         let key = CompressedPublicKey::try_from(*self)?;
         Ok(key.p2wpkh_script_code())
     }
@@ -243,7 +247,7 @@ impl PublicKey {
     ///
     /// If every `PublicKey` in the slice is `compressed == true` then this will sort
     /// the keys in a
-    /// [BIP67](https://github.com/bitcoin/bips/blob/master/bip-0067.mediawiki)
+    /// [BIP-0067](https://github.com/bitcoin/bips/blob/master/bip-0067.mediawiki)
     /// compliant way.
     ///
     /// # Example: Using with `sort_unstable_by_key`
@@ -263,13 +267,13 @@ impl PublicKey {
     ///     pk("0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68"),
     /// ];
     /// let sorted = [
-    ///     // These first 4 keys are in a BIP67 compatible sorted order
+    ///     // These first 4 keys are in a BIP-0067 compatible sorted order
     ///     // (since they are compressed)
     ///     pk("0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68"),
     ///     pk("028bde91b10013e08949a318018fedbd896534a549a278e220169ee2a36517c7aa"),
     ///     pk("032b8324c93575034047a52e9bca05a46d8347046b91a032eff07d5de8d3f2730b"),
     ///     pk("038f47dcd43ba6d97fc9ed2e3bba09b175a45fac55f0683e8cf771e8ced4572354"),
-    ///     // Uncompressed keys are not BIP67 compliant, but are sorted
+    ///     // Uncompressed keys are not BIP-0067 compliant, but are sorted
     ///     // after compressed keys in Bitcoin Core using `sortedmulti()`
     ///     pk("045d753414fa292ea5b8f56e39cfb6a0287b2546231a5cb05c4b14ab4b463d171f5128148985b23eccb1e2905374873b1f09b9487f47afa6b1f2b0083ac8b4f7e8"),
     ///     pk("04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc3816753d96001fd7cba3ce5372f5c9a0d63708183033538d07b1e532fc43aaacfa"),
@@ -291,7 +295,7 @@ impl PublicKey {
     }
 
     /// Deserializes a public key from a slice.
-    pub fn from_slice(data: &[u8]) -> Result<PublicKey, FromSliceError> {
+    pub fn from_slice(data: &[u8]) -> Result<Self, FromSliceError> {
         let compressed = match data.len() {
             33 => true,
             65 => false,
@@ -304,34 +308,28 @@ impl PublicKey {
             return Err(FromSliceError::InvalidKeyPrefix(data[0]));
         }
 
-        Ok(PublicKey { compressed, inner: secp256k1::PublicKey::from_slice(data)? })
+        Ok(Self { compressed, inner: secp256k1::PublicKey::from_slice(data)? })
     }
 
     /// Computes the public key as supposed to be used with this secret.
-    pub fn from_private_key<C: secp256k1::Signing>(
-        secp: &Secp256k1<C>,
-        sk: PrivateKey,
-    ) -> PublicKey {
-        sk.public_key(secp)
-    }
+    pub fn from_private_key(sk: PrivateKey) -> Self { sk.public_key() }
 
     /// Checks that `sig` is a valid ECDSA signature for `msg` using this public key.
-    pub fn verify<C: secp256k1::Verification>(
+    pub fn verify(
         &self,
-        secp: &Secp256k1<C>,
         msg: secp256k1::Message,
         sig: ecdsa::Signature,
     ) -> Result<(), secp256k1::Error> {
-        secp.verify_ecdsa(&msg, &sig.signature, &self.inner)
+        secp256k1::ecdsa::verify(&sig.signature, msg, &self.inner)
     }
 }
 
 impl From<secp256k1::PublicKey> for PublicKey {
-    fn from(pk: secp256k1::PublicKey) -> PublicKey { PublicKey::new(pk) }
+    fn from(pk: secp256k1::PublicKey) -> Self { Self::new(pk) }
 }
 
 impl From<PublicKey> for XOnlyPublicKey {
-    fn from(pk: PublicKey) -> XOnlyPublicKey { XOnlyPublicKey::new(pk.inner) }
+    fn from(pk: PublicKey) -> Self { Self::new(pk.inner) }
 }
 
 /// An opaque return type for PublicKey::to_sort_key.
@@ -346,23 +344,21 @@ impl fmt::Display for PublicKey {
 
 impl FromStr for PublicKey {
     type Err = ParsePublicKeyError;
-    fn from_str(s: &str) -> Result<PublicKey, ParsePublicKeyError> {
-        use HexToArrayError::*;
-
+    fn from_str(s: &str) -> Result<Self, ParsePublicKeyError> {
         match s.len() {
             66 => {
                 let bytes = <[u8; 33]>::from_hex(s).map_err(|e| match e {
-                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
-                    InvalidLength(_) => unreachable!("length checked already"),
+                    HexToArrayError::InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
+                    HexToArrayError::InvalidLength(_) => unreachable!("length checked already"),
                 })?;
-                Ok(PublicKey::from_slice(&bytes)?)
+                Ok(Self::from_slice(&bytes)?)
             }
             130 => {
                 let bytes = <[u8; 65]>::from_hex(s).map_err(|e| match e {
-                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
-                    InvalidLength(_) => unreachable!("length checked already"),
+                    HexToArrayError::InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
+                    HexToArrayError::InvalidLength(_) => unreachable!("length checked already"),
                 })?;
-                Ok(PublicKey::from_slice(&bytes)?)
+                Ok(Self::from_slice(&bytes)?)
             }
             len => Err(ParsePublicKeyError::InvalidHexLength(len)),
         }
@@ -383,11 +379,11 @@ hashes::impl_serde_for_newtype!(PubkeyHash, WPubkeyHash);
 impl_asref_push_bytes!(PubkeyHash, WPubkeyHash);
 
 impl From<PublicKey> for PubkeyHash {
-    fn from(key: PublicKey) -> PubkeyHash { key.pubkey_hash() }
+    fn from(key: PublicKey) -> Self { key.pubkey_hash() }
 }
 
 impl From<&PublicKey> for PubkeyHash {
-    fn from(key: &PublicKey) -> PubkeyHash { key.pubkey_hash() }
+    fn from(key: &PublicKey) -> Self { key.pubkey_hash() }
 }
 
 /// An always-compressed Bitcoin ECDSA public key.
@@ -404,7 +400,11 @@ impl CompressedPublicKey {
     }
 
     /// Returns the script code used to spend a P2WPKH input.
-    pub fn p2wpkh_script_code(&self) -> ScriptBuf {
+    ///
+    /// While the type returned is [`WitnessScriptBuf`], this is **not** a witness script and
+    /// should not be used as one. It is a special template defined in BIP 143 which is used
+    /// in place of a witness script for purposes of sighash computation.
+    pub fn p2wpkh_script_code(&self) -> WitnessScriptBuf {
         script::p2wpkh_script_code(self.wpubkey_hash())
     }
 
@@ -436,7 +436,7 @@ impl CompressedPublicKey {
     ///
     /// As the type name suggests, the key is serialized in compressed format.
     ///
-    /// Note that this can be used as a sort key to get BIP67-compliant sorting.
+    /// Note that this can be used as a sort key to get BIP-0067-compliant sorting.
     /// That's why this type doesn't have the `to_sort_key` method - it would duplicate this one.
     pub fn to_bytes(self) -> [u8; 33] { self.0.serialize() }
 
@@ -446,21 +446,17 @@ impl CompressedPublicKey {
     }
 
     /// Computes the public key as supposed to be used with this secret.
-    pub fn from_private_key<C: secp256k1::Signing>(
-        secp: &Secp256k1<C>,
-        sk: PrivateKey,
-    ) -> Result<Self, UncompressedPublicKeyError> {
-        sk.public_key(secp).try_into()
+    pub fn from_private_key(sk: PrivateKey) -> Result<Self, UncompressedPublicKeyError> {
+        sk.public_key().try_into()
     }
 
     /// Checks that `sig` is a valid ECDSA signature for `msg` using this public key.
-    pub fn verify<C: secp256k1::Verification>(
+    pub fn verify(
         &self,
-        secp: &Secp256k1<C>,
         msg: secp256k1::Message,
         sig: ecdsa::Signature,
     ) -> Result<(), secp256k1::Error> {
-        Ok(secp.verify_ecdsa(&msg, &sig.signature, &self.0)?)
+        Ok(secp256k1::ecdsa::verify(&sig.signature, msg, &self.0)?)
     }
 }
 
@@ -480,7 +476,7 @@ impl FromStr for CompressedPublicKey {
     type Err = ParseCompressedPublicKeyError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        CompressedPublicKey::from_slice(&<[u8; 33]>::from_hex(s)?).map_err(Into::into)
+        Self::from_slice(&<[u8; 33]>::from_hex(s)?).map_err(Into::into)
     }
 }
 
@@ -489,7 +485,7 @@ impl TryFrom<PublicKey> for CompressedPublicKey {
 
     fn try_from(value: PublicKey) -> Result<Self, Self::Error> {
         if value.compressed {
-            Ok(CompressedPublicKey(value.inner))
+            Ok(Self(value.inner))
         } else {
             Err(UncompressedPublicKeyError)
         }
@@ -497,7 +493,7 @@ impl TryFrom<PublicKey> for CompressedPublicKey {
 }
 
 impl From<CompressedPublicKey> for PublicKey {
-    fn from(value: CompressedPublicKey) -> Self { PublicKey::new(value.0) }
+    fn from(value: CompressedPublicKey) -> Self { Self::new(value.0) }
 }
 
 impl From<CompressedPublicKey> for XOnlyPublicKey {
@@ -534,31 +530,28 @@ pub struct PrivateKey {
 impl PrivateKey {
     /// Constructs a new compressed ECDSA private key using the secp256k1 algorithm and
     /// a secure random number generator.
-    #[cfg(feature = "rand-std")]
-    pub fn generate(network: impl Into<NetworkKind>) -> PrivateKey {
-        let secret_key = secp256k1::SecretKey::new(&mut rand::thread_rng());
-        PrivateKey::new(secret_key, network.into())
+    #[cfg(all(feature = "rand", feature = "std"))]
+    pub fn generate(network: impl Into<NetworkKind>) -> Self {
+        let secret_key = secp256k1::SecretKey::new(&mut rand::rng());
+        Self::new(secret_key, network.into())
     }
-    /// Constructs a new compressed ECDSA private key from the provided generic Secp256k1 private key
+    /// Constructs a new compressed ECDSA private key from the provided generic secp256k1 private key
     /// and the specified network.
-    pub fn new(key: secp256k1::SecretKey, network: impl Into<NetworkKind>) -> PrivateKey {
-        PrivateKey { compressed: true, network: network.into(), inner: key }
+    pub fn new(key: secp256k1::SecretKey, network: impl Into<NetworkKind>) -> Self {
+        Self { compressed: true, network: network.into(), inner: key }
     }
 
-    /// Constructs a new uncompressed (legacy) ECDSA private key from the provided generic Secp256k1
+    /// Constructs a new uncompressed (legacy) ECDSA private key from the provided generic secp256k1
     /// private key and the specified network.
-    pub fn new_uncompressed(
-        key: secp256k1::SecretKey,
-        network: impl Into<NetworkKind>,
-    ) -> PrivateKey {
-        PrivateKey { compressed: false, network: network.into(), inner: key }
+    pub fn new_uncompressed(key: secp256k1::SecretKey, network: impl Into<NetworkKind>) -> Self {
+        Self { compressed: false, network: network.into(), inner: key }
     }
 
     /// Constructs a new public key from this private key.
-    pub fn public_key<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> PublicKey {
+    pub fn public_key(&self) -> PublicKey {
         PublicKey {
             compressed: self.compressed,
-            inner: secp256k1::PublicKey::from_secret_key(secp, &self.inner),
+            inner: secp256k1::PublicKey::from_secret_key(&self.inner),
         }
     }
 
@@ -573,8 +566,8 @@ impl PrivateKey {
     pub fn from_byte_array(
         data: [u8; 32],
         network: impl Into<NetworkKind>,
-    ) -> Result<PrivateKey, secp256k1::Error> {
-        Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(&data)?, network))
+    ) -> Result<Self, secp256k1::Error> {
+        Ok(Self::new(secp256k1::SecretKey::from_secret_bytes(data)?, network))
     }
 
     /// Deserializes a private key from a slice.
@@ -582,7 +575,7 @@ impl PrivateKey {
     pub fn from_slice(
         data: &[u8],
         network: impl Into<NetworkKind>,
-    ) -> Result<PrivateKey, secp256k1::Error> {
+    ) -> Result<Self, secp256k1::Error> {
         let array = data.try_into().map_err(|_| secp256k1::Error::InvalidSecretKey)?;
         Self::from_byte_array(array, network)
     }
@@ -612,7 +605,7 @@ impl PrivateKey {
     }
 
     /// Parses the WIF encoded private key.
-    pub fn from_wif(wif: &str) -> Result<PrivateKey, FromWifError> {
+    pub fn from_wif(wif: &str) -> Result<Self, FromWifError> {
         let data = base58::decode_check(wif)?;
 
         let (compressed, data) = if let Ok(data) = <&[u8; 33]>::try_from(&*data) {
@@ -636,21 +629,17 @@ impl PrivateKey {
             }
         };
 
-        Ok(PrivateKey { compressed, network, inner: secp256k1::SecretKey::from_byte_array(key)? })
+        Ok(Self { compressed, network, inner: secp256k1::SecretKey::from_secret_bytes(*key)? })
     }
 
     /// Returns a new private key with the negated secret value.
     ///
     /// The resulting key corresponds to the same x-only public key (identical x-coordinate)
     /// but with the opposite y-coordinate parity. This is useful for ensuring compatibility
-    /// with specific public key formats and BIP-340 requirements.
+    /// with specific public key formats and BIP-0340 requirements.
     #[inline]
     pub fn negate(&self) -> Self {
-        PrivateKey {
-            compressed: self.compressed,
-            network: self.network,
-            inner: self.inner.negate(),
-        }
+        Self { compressed: self.compressed, network: self.network, inner: self.inner.negate() }
     }
 }
 
@@ -660,7 +649,7 @@ impl fmt::Display for PrivateKey {
 
 impl FromStr for PrivateKey {
     type Err = FromWifError;
-    fn from_str(s: &str) -> Result<PrivateKey, FromWifError> { PrivateKey::from_wif(s) }
+    fn from_str(s: &str) -> Result<Self, FromWifError> { Self::from_wif(s) }
 }
 
 impl ops::Index<ops::RangeFull> for PrivateKey {
@@ -677,7 +666,7 @@ impl serde::Serialize for PrivateKey {
 
 #[cfg(feature = "serde")]
 impl<'de> serde::Deserialize<'de> for PrivateKey {
-    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<PrivateKey, D::Error> {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
         struct WifVisitor;
 
         impl serde::de::Visitor<'_> for WifVisitor {
@@ -724,7 +713,7 @@ impl serde::Serialize for PublicKey {
 
 #[cfg(feature = "serde")]
 impl<'de> serde::Deserialize<'de> for PublicKey {
-    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<PublicKey, D::Error> {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
         if d.is_human_readable() {
             struct HexVisitor;
 
@@ -842,10 +831,10 @@ impl<'de> serde::Deserialize<'de> for CompressedPublicKey {
         }
     }
 }
-/// Untweaked BIP-340 X-coord-only public key.
+/// Untweaked BIP-0340 X-coord-only public key.
 pub type UntweakedPublicKey = XOnlyPublicKey;
 
-/// Tweaked BIP-340 X-coord-only public key.
+/// Tweaked BIP-0340 X-coord-only public key.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(transparent))]
@@ -861,22 +850,21 @@ impl fmt::Display for TweakedPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
-/// Untweaked BIP-340 key pair.
+/// Untweaked BIP-0340 key pair.
 pub type UntweakedKeypair = Keypair;
 
-/// Tweaked BIP-340 key pair.
+/// Tweaked BIP-0340 key pair.
 ///
 /// # Examples
 ///
 /// ```
-/// # #[cfg(feature = "rand-std")] {
+/// # #[cfg(all(feature = "rand", feature = "std"))] {
 /// # use bitcoin::key::{Keypair, TweakedKeypair, TweakedPublicKey};
-/// # use bitcoin::secp256k1::{rand, Secp256k1};
-/// # let secp = Secp256k1::new();
-/// # let keypair = TweakedKeypair::dangerous_assume_tweaked(Keypair::new(&secp, &mut rand::thread_rng()));
+/// # use bitcoin::secp256k1::rand;
+/// # let keypair = TweakedKeypair::dangerous_assume_tweaked(Keypair::new(&mut rand::rng()));
 /// // There are various conversion methods available to get a tweaked pubkey from a tweaked keypair.
 /// let (_pk, _parity) = keypair.public_parts();
-/// let _pk  = TweakedPublicKey::from_keypair(keypair);
+/// let _pk = TweakedPublicKey::from_keypair(keypair);
 /// let _pk = TweakedPublicKey::from(keypair);
 /// # }
 /// ```
@@ -885,7 +873,7 @@ pub type UntweakedKeypair = Keypair;
 #[cfg_attr(feature = "serde", serde(transparent))]
 pub struct TweakedKeypair(Keypair);
 
-/// A trait for tweaking BIP340 key types (x-only public keys and key pairs).
+/// A trait for tweaking BIP-0340 key types (x-only public keys and key pairs).
 pub trait TapTweak {
     /// Tweaked key type with optional auxiliary information.
     type TweakedAux;
@@ -905,11 +893,7 @@ pub trait TapTweak {
     /// # Returns
     ///
     /// The tweaked key and its parity.
-    fn tap_tweak<C: Verification>(
-        self,
-        secp: &Secp256k1<C>,
-        merkle_root: Option<TapNodeHash>,
-    ) -> Self::TweakedAux;
+    fn tap_tweak(self, merkle_root: Option<TapNodeHash>) -> Self::TweakedAux;
 
     /// Directly converts an [`UntweakedPublicKey`] to a [`TweakedPublicKey`].
     ///
@@ -935,15 +919,11 @@ impl TapTweak for UntweakedPublicKey {
     /// # Returns
     ///
     /// The tweaked key and its parity.
-    fn tap_tweak<C: Verification>(
-        self,
-        secp: &Secp256k1<C>,
-        merkle_root: Option<TapNodeHash>,
-    ) -> (TweakedPublicKey, Parity) {
+    fn tap_tweak(self, merkle_root: Option<TapNodeHash>) -> (TweakedPublicKey, Parity) {
         let tweak = TapTweakHash::from_key_and_merkle_root(self, merkle_root).to_scalar();
-        let (output_key, parity) = self.add_tweak(secp, &tweak).expect("Tap tweak failed");
+        let (output_key, parity) = self.add_tweak(&tweak).expect("Tap tweak failed");
 
-        debug_assert!(self.tweak_add_check(secp, &output_key, parity, tweak));
+        debug_assert!(self.tweak_add_check(&output_key, parity, tweak));
         (TweakedPublicKey(output_key), parity)
     }
 
@@ -964,14 +944,10 @@ impl TapTweak for UntweakedKeypair {
     /// # Returns
     ///
     /// The tweaked keypair.
-    fn tap_tweak<C: Verification>(
-        self,
-        secp: &Secp256k1<C>,
-        merkle_root: Option<TapNodeHash>,
-    ) -> TweakedKeypair {
+    fn tap_tweak(self, merkle_root: Option<TapNodeHash>) -> TweakedKeypair {
         let (pubkey, _parity) = XOnlyPublicKey::from_keypair(&self);
         let tweak = TapTweakHash::from_key_and_merkle_root(pubkey, merkle_root).to_scalar();
-        let tweaked = self.add_xonly_tweak(secp, &tweak).expect("Tap tweak failed");
+        let tweaked = self.add_xonly_tweak(&tweak).expect("Tap tweak failed");
         TweakedKeypair(tweaked)
     }
 
@@ -983,7 +959,7 @@ impl TweakedPublicKey {
     #[inline]
     pub fn from_keypair(keypair: TweakedKeypair) -> Self {
         let (xonly, _parity) = keypair.0.x_only_public_key();
-        TweakedPublicKey(xonly.into())
+        Self(xonly.into())
     }
 
     /// Constructs a new [`TweakedPublicKey`] from a [`XOnlyPublicKey`]. No tweak is applied, consider
@@ -992,9 +968,7 @@ impl TweakedPublicKey {
     /// This method is dangerous and can lead to loss of funds if used incorrectly.
     /// Specifically, in multi-party protocols a peer can provide a value that allows them to steal.
     #[inline]
-    pub fn dangerous_assume_tweaked(key: XOnlyPublicKey) -> TweakedPublicKey {
-        TweakedPublicKey(key)
-    }
+    pub fn dangerous_assume_tweaked(key: XOnlyPublicKey) -> Self { Self(key) }
 
     /// Returns the underlying public key.
     #[inline]
@@ -1022,7 +996,7 @@ impl TweakedKeypair {
     /// This method is dangerous and can lead to loss of funds if used incorrectly.
     /// Specifically, in multi-party protocols a peer can provide a value that allows them to steal.
     #[inline]
-    pub fn dangerous_assume_tweaked(pair: Keypair) -> TweakedKeypair { TweakedKeypair(pair) }
+    pub fn dangerous_assume_tweaked(pair: Keypair) -> Self { Self(pair) }
 
     /// Returns the underlying key pair.
     #[inline]
@@ -1058,7 +1032,7 @@ impl From<TweakedKeypair> for Keypair {
 
 impl From<TweakedKeypair> for TweakedPublicKey {
     #[inline]
-    fn from(pair: TweakedKeypair) -> Self { TweakedPublicKey::from_keypair(pair) }
+    fn from(pair: TweakedKeypair) -> Self { Self::from_keypair(pair) }
 }
 
 /// Error returned while generating key from slice.
@@ -1067,7 +1041,7 @@ impl From<TweakedKeypair> for TweakedPublicKey {
 pub enum FromSliceError {
     /// Invalid key prefix error.
     InvalidKeyPrefix(u8),
-    /// A Secp256k1 error.
+    /// A secp256k1 error.
     Secp256k1(secp256k1::Error),
     /// Invalid Length of the slice.
     InvalidLength(usize),
@@ -1079,12 +1053,11 @@ impl From<Infallible> for FromSliceError {
 
 impl fmt::Display for FromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use FromSliceError::*;
-
         match self {
-            Secp256k1(e) => write_err!(f, "secp256k1"; e),
-            InvalidKeyPrefix(b) => write!(f, "key prefix invalid: {}", b),
-            InvalidLength(got) => write!(f, "slice length should be 33 or 65 bytes, got: {}", got),
+            Self::Secp256k1(e) => write_err!(f, "secp256k1"; e),
+            Self::InvalidKeyPrefix(b) => write!(f, "key prefix invalid: {}", b),
+            Self::InvalidLength(got) =>
+                write!(f, "slice length should be 33 or 65 bytes, got: {}", got),
         }
     }
 }
@@ -1092,11 +1065,9 @@ impl fmt::Display for FromSliceError {
 #[cfg(feature = "std")]
 impl std::error::Error for FromSliceError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use FromSliceError::*;
-
-        match *self {
-            Secp256k1(ref e) => Some(e),
-            InvalidKeyPrefix(_) | InvalidLength(_) => None,
+        match self {
+            Self::Secp256k1(ref e) => Some(e),
+            Self::InvalidKeyPrefix(_) | Self::InvalidLength(_) => None,
         }
     }
 }
@@ -1127,16 +1098,15 @@ impl From<Infallible> for FromWifError {
 
 impl fmt::Display for FromWifError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use FromWifError::*;
-
-        match *self {
-            Base58(ref e) => write_err!(f, "invalid base58"; e),
-            InvalidBase58PayloadLength(ref e) =>
+        match self {
+            Self::Base58(ref e) => write_err!(f, "invalid base58"; e),
+            Self::InvalidBase58PayloadLength(ref e) =>
                 write_err!(f, "decoded base58 data was an invalid length"; e),
-            InvalidAddressVersion(ref e) =>
+            Self::InvalidAddressVersion(ref e) =>
                 write_err!(f, "decoded base58 data contained an invalid address version byte"; e),
-            Secp256k1(ref e) => write_err!(f, "private key validation failed"; e),
-            InvalidWifCompressionFlag(ref e) => write_err!(f, "invalid WIF compression flag";e),
+            Self::Secp256k1(ref e) => write_err!(f, "private key validation failed"; e),
+            Self::InvalidWifCompressionFlag(ref e) =>
+                write_err!(f, "invalid WIF compression flag"; e),
         }
     }
 }
@@ -1144,14 +1114,12 @@ impl fmt::Display for FromWifError {
 #[cfg(feature = "std")]
 impl std::error::Error for FromWifError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use FromWifError::*;
-
-        match *self {
-            Base58(ref e) => Some(e),
-            InvalidBase58PayloadLength(ref e) => Some(e),
-            InvalidAddressVersion(ref e) => Some(e),
-            Secp256k1(ref e) => Some(e),
-            InvalidWifCompressionFlag(ref e) => Some(e),
+        match self {
+            Self::Base58(ref e) => Some(e),
+            Self::InvalidBase58PayloadLength(ref e) => Some(e),
+            Self::InvalidAddressVersion(ref e) => Some(e),
+            Self::Secp256k1(ref e) => Some(e),
+            Self::InvalidWifCompressionFlag(ref e) => Some(e),
         }
     }
 }
@@ -1165,19 +1133,15 @@ impl From<secp256k1::Error> for FromWifError {
 }
 
 impl From<InvalidBase58PayloadLengthError> for FromWifError {
-    fn from(e: InvalidBase58PayloadLengthError) -> FromWifError {
-        Self::InvalidBase58PayloadLength(e)
-    }
+    fn from(e: InvalidBase58PayloadLengthError) -> Self { Self::InvalidBase58PayloadLength(e) }
 }
 
 impl From<InvalidAddressVersionError> for FromWifError {
-    fn from(e: InvalidAddressVersionError) -> FromWifError { Self::InvalidAddressVersion(e) }
+    fn from(e: InvalidAddressVersionError) -> Self { Self::InvalidAddressVersion(e) }
 }
 
 impl From<InvalidWifCompressionFlagError> for FromWifError {
-    fn from(e: InvalidWifCompressionFlagError) -> FromWifError {
-        Self::InvalidWifCompressionFlag(e)
-    }
+    fn from(e: InvalidWifCompressionFlagError) -> Self { Self::InvalidWifCompressionFlag(e) }
 }
 
 /// Error returned while constructing public key from string.
@@ -1197,11 +1161,10 @@ impl From<Infallible> for ParsePublicKeyError {
 
 impl fmt::Display for ParsePublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParsePublicKeyError::*;
-        match *self {
-            Encoding(ref e) => write_err!(f, "string error"; e),
-            InvalidChar(ref e) => write_err!(f, "hex decoding"; e),
-            InvalidHexLength(got) =>
+        match self {
+            Self::Encoding(ref e) => write_err!(f, "string error"; e),
+            Self::InvalidChar(ref e) => write_err!(f, "hex decoding"; e),
+            Self::InvalidHexLength(got) =>
                 write!(f, "pubkey string should be 66 or 130 digits long, got: {}", got),
         }
     }
@@ -1210,12 +1173,10 @@ impl fmt::Display for ParsePublicKeyError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParsePublicKeyError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParsePublicKeyError::*;
-
-        match *self {
-            Encoding(ref e) => Some(e),
-            InvalidChar(ref e) => Some(e),
-            InvalidHexLength(_) => None,
+        match self {
+            Self::Encoding(ref e) => Some(e),
+            Self::InvalidChar(ref e) => Some(e),
+            Self::InvalidHexLength(_) => None,
         }
     }
 }
@@ -1227,7 +1188,7 @@ impl From<FromSliceError> for ParsePublicKeyError {
 /// Error returned when parsing a [`CompressedPublicKey`] from a string.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ParseCompressedPublicKeyError {
-    /// Secp256k1 Error.
+    /// secp256k1 Error.
     Secp256k1(secp256k1::Error),
     /// hex to array conversion error.
     Hex(hex::HexToArrayError),
@@ -1239,10 +1200,9 @@ impl From<Infallible> for ParseCompressedPublicKeyError {
 
 impl fmt::Display for ParseCompressedPublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseCompressedPublicKeyError::*;
         match self {
-            Secp256k1(e) => write_err!(f, "secp256k1 error"; e),
-            Hex(e) => write_err!(f, "invalid hex"; e),
+            Self::Secp256k1(e) => write_err!(f, "secp256k1 error"; e),
+            Self::Hex(e) => write_err!(f, "invalid hex"; e),
         }
     }
 }
@@ -1250,11 +1210,9 @@ impl fmt::Display for ParseCompressedPublicKeyError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseCompressedPublicKeyError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseCompressedPublicKeyError::*;
-
         match self {
-            Secp256k1(e) => Some(e),
-            Hex(e) => Some(e),
+            Self::Secp256k1(e) => Some(e),
+            Self::Hex(e) => Some(e),
         }
     }
 }
@@ -1383,8 +1341,8 @@ impl AsRef<[u8; 32]> for SerializedXOnlyPublicKey {
     fn as_ref(&self) -> &[u8; 32] { self.as_byte_array() }
 }
 
-impl From<&SerializedXOnlyPublicKey> for SerializedXOnlyPublicKey {
-    fn from(borrowed: &SerializedXOnlyPublicKey) -> Self { *borrowed }
+impl From<&Self> for SerializedXOnlyPublicKey {
+    fn from(borrowed: &Self) -> Self { *borrowed }
 }
 
 impl fmt::Debug for SerializedXOnlyPublicKey {
@@ -1458,8 +1416,7 @@ mod tests {
         assert!(sk.compressed);
         assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
 
-        let secp = Secp256k1::new();
-        let pk = Address::p2pkh(sk.public_key(&secp), sk.network);
+        let pk = Address::p2pkh(sk.public_key(), sk.network);
         assert_eq!(&pk.to_string(), "mqwpxxvfv3QbM8PU8uBx2jaNt9btQqvQNx");
 
         // test string conversion
@@ -1475,8 +1432,7 @@ mod tests {
         assert!(!sk.compressed);
         assert_eq!(&sk.to_wif(), "5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3");
 
-        let secp = Secp256k1::new();
-        let mut pk = sk.public_key(&secp);
+        let mut pk = sk.public_key();
         assert!(!pk.compressed);
         assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
         assert_eq!(pk, "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"
@@ -1553,9 +1509,8 @@ mod tests {
             0xe9, 0x71, 0xd8, 0x6b, 0x5e, 0x61, 0x87, 0x5d,
         ];
 
-        let s = Secp256k1::new();
         let sk = KEY_WIF.parse::<PrivateKey>().unwrap();
-        let pk = PublicKey::from_private_key(&s, sk);
+        let pk = PublicKey::from_private_key(sk);
         let pk_u = PublicKey { inner: pk.inner, compressed: false };
 
         assert_tokens(&sk, &[Token::BorrowedStr(KEY_WIF)]);
@@ -1645,7 +1600,7 @@ mod tests {
             v.into_iter().map(|s: &str| s.parse::<PublicKey>().unwrap()).collect::<Vec<_>>()
         };
         let vectors = vec![
-            // Start BIP67 vectors
+            // Start BIP-0067 vectors
             // Vector 1
             Vector {
                 input: fmt(vec![
@@ -1746,12 +1701,11 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn public_key_constructors() {
         use secp256k1::rand;
 
-        let secp = Secp256k1::new();
-        let kp = Keypair::new(&secp, &mut rand::thread_rng());
+        let kp = Keypair::new(&mut rand::rng());
 
         let _ = PublicKey::new(kp);
         let _ = PublicKey::new_uncompressed(kp);
@@ -1817,7 +1771,7 @@ mod tests {
             assert_eq!(err.invalid_char(), b'g');
             assert_eq!(err.pos(), 129);
         } else {
-            panic!("Expected Invalid char error");
+            panic!("expected ParsePublicKeyError::InvalidChar");
         }
 
         let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1ag";
@@ -1828,7 +1782,7 @@ mod tests {
             assert_eq!(err.invalid_char(), b'g');
             assert_eq!(err.pos(), 65);
         } else {
-            panic!("Expected Invalid char error");
+            panic!("expected ParsePublicKeyError::InvalidChar");
         }
     }
 
@@ -1840,4 +1794,29 @@ mod tests {
         assert!(PrivateKey::from_slice(&[1u8; 31], Network::Regtest).is_err());
         assert!(PrivateKey::from_slice(&[1u8; 33], Network::Regtest).is_err());
     }
+
+    #[test]
+    fn xonly_pubkey_from_bytes() {
+        let key_bytes = &<[u8; 32]>::from_hex(
+            "5b1e57ec453cd33fdc7cfc901450a3931fd315422558f2fb7fefb064e6e7d60d",
+        )
+        .expect("Failed to convert hex string to byte array");
+        let xonly_pub_key = XOnlyPublicKey::from_byte_array(key_bytes)
+            .expect("Failed to create an XOnlyPublicKey from a byte array");
+        // Confirm that the public key from bytes serializes back to the same bytes
+        assert_eq!(&xonly_pub_key.serialize(), key_bytes);
+    }
+
+    #[test]
+    fn xonly_pubkey_into_inner() {
+        let key_bytes = &<[u8; 32]>::from_hex(
+            "5b1e57ec453cd33fdc7cfc901450a3931fd315422558f2fb7fefb064e6e7d60d",
+        )
+        .expect("Failed to convert hex string to byte array");
+        let inner_key = secp256k1::XOnlyPublicKey::from_byte_array(*key_bytes)
+            .expect("Failed to create a secp256k1 x-only public key from a byte array");
+        let btc_pubkey = XOnlyPublicKey::new(inner_key);
+        // Confirm that the into_inner() returns the same data that was initially wrapped
+        assert_eq!(inner_key, btc_pubkey.into_inner());
+    }
 }
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 7cb92cd7e7..5b300515f2 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -3,13 +3,14 @@
 //! Signature hash implementation (used in transaction signing).
 //!
 //! Efficient implementation of the algorithm to compute the message to be signed according to
-//! [Bip341](https://github.com/bitcoin/bips/blob/150ab6f5c3aca9da05fccc5b435e9667853407f4/bip-0341.mediawiki),
-//! [Bip143](https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki)
-//! and legacy (before Bip143).
+//! [BIP-0341], [BIP-0143] and legacy (before BIP-0143).
 //!
 //! Computing signature hashes is required to sign a transaction and this module is designed to
 //! handle its complexity efficiently. Computing these hashes is as simple as creating
 //! [`SighashCache`] and calling its methods.
+//!
+//! [BIP-0341]: <https://github.com/bitcoin/bips/blob/150ab6f5c3aca9da05fccc5b435e9667853407f4/bip-0341.mediawiki>
+//! [BIP-0143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
 
 use core::convert::Infallible;
 use core::{fmt, str};
@@ -20,13 +21,15 @@ use hashes::{hash_newtype, sha256, sha256d, sha256t, sha256t_tag};
 use internals::write_err;
 use io::Write;
 
-use crate::address::script_pubkey::ScriptExt as _;
 use crate::consensus::{encode, Encodable};
 use crate::prelude::{Borrow, BorrowMut, String, ToOwned};
+use crate::script::{ScriptExt as _, ScriptHashableTag};
 use crate::taproot::{LeafVersion, TapLeafHash, TapLeafTag, TAPROOT_ANNEX_PREFIX};
 use crate::transaction::TransactionExt as _;
 use crate::witness::Witness;
-use crate::{transaction, Amount, Script, Sequence, Transaction, TxOut};
+use crate::{
+    transaction, Amount, ScriptPubKey, Sequence, TapScript, Transaction, TxOut, WitnessScript,
+};
 
 /// Used for signature hash for invalid use of SIGHASH_SINGLE.
 #[rustfmt::skip]
@@ -83,7 +86,7 @@ sha256t_tag! {
 hash_newtype! {
     /// Taproot-tagged hash with tag \"TapSighash\".
     ///
-    /// This hash type is used for computing Taproot signature hash."
+    /// This hash type is used for computing Taproot signature hash.
     pub struct TapSighash(sha256t::Hash<TapSighashTag>);
 }
 
@@ -91,8 +94,6 @@ hashes::impl_hex_for_newtype!(TapSighash);
 #[cfg(feature = "serde")]
 hashes::impl_serde_for_newtype!(TapSighash);
 
-impl_message_from_hash!(TapSighash);
-
 /// Efficiently calculates signature hash message for legacy, SegWit and Taproot inputs.
 #[derive(Debug)]
 pub struct SighashCache<T: Borrow<Transaction>> {
@@ -139,7 +140,7 @@ struct TaprootCache {
 
 /// Contains outputs of previous transactions. In the case [`TapSighashType`] variant is
 /// `SIGHASH_ANYONECANPAY`, [`Prevouts::One`] may be used.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub enum Prevouts<'u, T>
 where
     T: 'u + Borrow<TxOut>,
@@ -158,9 +159,9 @@ const KEY_VERSION_0: u8 = 0u8;
 /// Information related to the script path spending.
 ///
 /// This can be hashed into a [`TapLeafHash`].
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct ScriptPath<'s> {
-    script: &'s Script,
+    script: &'s TapScript,
     leaf_version: LeafVersion,
 }
 
@@ -231,7 +232,7 @@ where
 {
     fn check_all(&self, tx: &Transaction) -> Result<(), PrevoutsSizeError> {
         if let Prevouts::All(prevouts) = self {
-            if prevouts.len() != tx.input.len() {
+            if prevouts.len() != tx.inputs.len() {
                 return Err(PrevoutsSizeError);
             }
         }
@@ -277,7 +278,7 @@ impl std::error::Error for PrevoutsSizeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
 
-/// A single prevout was been provided but all prevouts are needed without `ANYONECANPAY`.
+/// A single prevout was provided but all prevouts are needed without `ANYONECANPAY`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub struct PrevoutsKindError;
@@ -309,11 +310,9 @@ impl From<Infallible> for PrevoutsIndexError {
 
 impl fmt::Display for PrevoutsIndexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use PrevoutsIndexError::*;
-
-        match *self {
-            InvalidOneIndex => write!(f, "invalid index when accessing a Prevouts::One kind"),
-            InvalidAllIndex => write!(f, "invalid index when accessing a Prevouts::All kind"),
+        match self {
+            Self::InvalidOneIndex => write!(f, "invalid index when accessing a Prevouts::One kind"),
+            Self::InvalidAllIndex => write!(f, "invalid index when accessing a Prevouts::All kind"),
         }
     }
 }
@@ -321,21 +320,21 @@ impl fmt::Display for PrevoutsIndexError {
 #[cfg(feature = "std")]
 impl std::error::Error for PrevoutsIndexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use PrevoutsIndexError::*;
-
-        match *self {
-            InvalidOneIndex | InvalidAllIndex => None,
+        match self {
+            Self::InvalidOneIndex | Self::InvalidAllIndex => None,
         }
     }
 }
 
 impl<'s> ScriptPath<'s> {
     /// Constructs a new `ScriptPath` structure.
-    pub fn new(script: &'s Script, leaf_version: LeafVersion) -> Self {
+    pub fn new(script: &'s TapScript, leaf_version: LeafVersion) -> Self {
         ScriptPath { script, leaf_version }
     }
     /// Constructs a new `ScriptPath` structure using default leaf version value.
-    pub fn with_defaults(script: &'s Script) -> Self { Self::new(script, LeafVersion::TapScript) }
+    pub fn with_defaults(script: &'s TapScript) -> Self {
+        Self::new(script, LeafVersion::TapScript)
+    }
     /// Computes the leaf hash for this `ScriptPath`.
     pub fn leaf_hash(&self) -> TapLeafHash {
         let mut enc = sha256t::Hash::<TapLeafTag>::engine();
@@ -343,8 +342,8 @@ impl<'s> ScriptPath<'s> {
         self.leaf_version
             .to_consensus()
             .consensus_encode(&mut enc)
-            .expect("writing to hash enging should never fail");
-        self.script.consensus_encode(&mut enc).expect("writing to hash enging should never fail");
+            .expect("writing to hash engine should never fail");
+        self.script.consensus_encode(&mut enc).expect("writing to hash engine should never fail");
 
         let inner = sha256t::Hash::<TapLeafTag>::from_engine(enc);
         TapLeafHash::from_byte_array(inner.to_byte_array())
@@ -352,7 +351,7 @@ impl<'s> ScriptPath<'s> {
 }
 
 impl<'s> From<ScriptPath<'s>> for TapLeafHash {
-    fn from(script_path: ScriptPath<'s>) -> TapLeafHash { script_path.leaf_hash() }
+    fn from(script_path: ScriptPath<'s>) -> Self { script_path.leaf_hash() }
 }
 
 /// Hashtype of an input's signature, encoded in the last byte of the signature.
@@ -416,7 +415,7 @@ impl str::FromStr for EcdsaSighashType {
 
 impl EcdsaSighashType {
     /// Splits the sighash flag into the "real" sighash flag and the ANYONECANPAY boolean.
-    pub(crate) fn split_anyonecanpay_flag(self) -> (EcdsaSighashType, bool) {
+    pub(crate) fn split_anyonecanpay_flag(self) -> (Self, bool) {
         use EcdsaSighashType::*;
 
         match self {
@@ -444,9 +443,9 @@ impl EcdsaSighashType {
     ///
     /// This might cause unexpected behavior because it does not roundtrip. That is,
     /// `EcdsaSighashType::from_consensus(n) as u32 != n` for non-standard values of `n`. While
-    /// verifying signatures, the user should retain the `n` and use it compute the signature hash
+    /// verifying signatures, the user should retain the `n` and use it to compute the signature hash
     /// message.
-    pub fn from_consensus(n: u32) -> EcdsaSighashType {
+    pub fn from_consensus(n: u32) -> Self {
         use EcdsaSighashType::*;
 
         // In Bitcoin Core, the SignatureHash function will mask the (int32) value with
@@ -473,7 +472,7 @@ impl EcdsaSighashType {
     /// # Errors
     ///
     /// If `n` is a non-standard sighash value.
-    pub fn from_standard(n: u32) -> Result<EcdsaSighashType, NonStandardSighashTypeError> {
+    pub fn from_standard(n: u32) -> Result<Self, NonStandardSighashTypeError> {
         use EcdsaSighashType::*;
 
         match n {
@@ -511,7 +510,7 @@ impl From<EcdsaSighashType> for TapSighashType {
 
 impl TapSighashType {
     /// Breaks the sighash flag into the "real" sighash flag and the `SIGHASH_ANYONECANPAY` boolean.
-    pub(crate) fn split_anyonecanpay_flag(self) -> (TapSighashType, bool) {
+    pub(crate) fn split_anyonecanpay_flag(self) -> (Self, bool) {
         use TapSighashType::*;
 
         match self {
@@ -601,7 +600,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
     /// sighashes to be valid, no fields in the transaction may change except for script_sig and
     /// witness.
     pub fn new(tx: R) -> Self {
-        SighashCache { tx, common_cache: None, taproot_cache: None, segwit_cache: None }
+        Self { tx, common_cache: None, taproot_cache: None, segwit_cache: None }
     }
 
     /// Returns the reference to the cached transaction.
@@ -610,7 +609,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
     /// Destroys the cache and recovers the stored transaction.
     pub fn into_transaction(self) -> R { self.tx }
 
-    /// Encodes the BIP341 signing data for any flag type into a given object implementing the
+    /// Encodes the BIP-0341 signing data for any flag type into a given object implementing the
     /// [`io::Write`] trait.
     ///
     /// In order to sign, the data written by this function must be hashed using a tagged hash. For
@@ -686,7 +685,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             let txin = &self.tx.borrow().tx_in(input_index).map_err(SigningDataError::sighash)?;
             let previous_output = prevouts.get(input_index).map_err(SigningDataError::sighash)?;
             txin.previous_output.consensus_encode(writer)?;
-            previous_output.value.consensus_encode(writer)?;
+            previous_output.amount.consensus_encode(writer)?;
             previous_output.script_pubkey.consensus_encode(writer)?;
             txin.sequence.consensus_encode(writer)?;
         } else {
@@ -710,11 +709,11 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             let mut enc = sha256::Hash::engine();
             self.tx
                 .borrow()
-                .output
+                .outputs
                 .get(input_index)
                 .ok_or(TaprootError::SingleMissingOutput(SingleMissingOutputError {
                     input_index,
-                    outputs_length: self.tx.borrow().output.len(),
+                    outputs_length: self.tx.borrow().outputs.len(),
                 }))
                 .map_err(SigningDataError::Sighash)?
                 .consensus_encode(&mut enc)?;
@@ -735,7 +734,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         Ok(())
     }
 
-    /// Computes the BIP341 sighash for any flag type.
+    /// Computes the BIP-0341 sighash for any flag type.
     pub fn taproot_signature_hash<T: Borrow<TxOut>>(
         &mut self,
         input_index: usize,
@@ -758,7 +757,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         Ok(TapSighash::from_byte_array(inner.to_byte_array()))
     }
 
-    /// Computes the BIP341 sighash for a key spend.
+    /// Computes the BIP-0341 sighash for a key spend.
     pub fn taproot_key_spend_signature_hash<T: Borrow<TxOut>>(
         &mut self,
         input_index: usize,
@@ -779,7 +778,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         Ok(TapSighash::from_byte_array(inner.to_byte_array()))
     }
 
-    /// Computes the BIP341 sighash for a script spend.
+    /// Computes the BIP-0341 sighash for a script spend.
     ///
     /// Assumes the default `OP_CODESEPARATOR` position of `0xFFFFFFFF`. Custom values can be
     /// provided through the more fine-grained API of [`SighashCache::taproot_encode_signing_data_to`].
@@ -804,11 +803,11 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         Ok(TapSighash::from_byte_array(inner.to_byte_array()))
     }
 
-    /// Encodes the BIP143 signing data for any flag type into a given object implementing the
+    /// Encodes the BIP-0143 signing data for any flag type into a given object implementing the
     /// [`std::io::Write`] trait.
     ///
     /// `script_code` is dependent on the type of the spend transaction. For p2wpkh use
-    /// [`Script::p2wpkh_script_code`], for p2wsh just pass in the witness script. (Also see
+    /// [`WitnessScript::p2wpkh_script_code`], for p2wsh just pass in the witness script. (Also see
     /// [`Self::p2wpkh_signature_hash`] and [`SighashCache::p2wsh_signature_hash`].)
     ///
     /// In order to sign, the data written by this function must be hashed using a double SHA256
@@ -818,8 +817,8 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         &mut self,
         writer: &mut W,
         input_index: usize,
-        script_code: &Script,
-        value: Amount,
+        script_code: &WitnessScript,
+        amount: Amount,
         sighash_type: EcdsaSighashType,
     ) -> Result<(), SigningDataError<transaction::InputsIndexError>> {
         let zero_hash = [0; 32];
@@ -847,16 +846,17 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             let txin = &self.tx.borrow().tx_in(input_index).map_err(SigningDataError::sighash)?;
             txin.previous_output.consensus_encode(writer)?;
             script_code.consensus_encode(writer)?;
-            value.consensus_encode(writer)?;
+            amount.consensus_encode(writer)?;
             txin.sequence.consensus_encode(writer)?;
         }
 
         if sighash != EcdsaSighashType::Single && sighash != EcdsaSighashType::None {
             self.segwit_cache().outputs.consensus_encode(writer)?;
-        } else if sighash == EcdsaSighashType::Single && input_index < self.tx.borrow().output.len()
+        } else if sighash == EcdsaSighashType::Single
+            && input_index < self.tx.borrow().outputs.len()
         {
             let mut single_enc = LegacySighash::engine();
-            self.tx.borrow().output[input_index].consensus_encode(&mut single_enc)?;
+            self.tx.borrow().outputs[input_index].consensus_encode(&mut single_enc)?;
             let hash = LegacySighash::from_engine(single_enc);
             writer.write_all(hash.as_byte_array())?;
         } else {
@@ -868,15 +868,15 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         Ok(())
     }
 
-    /// Computes the BIP143 sighash to spend a p2wpkh transaction for any flag type.
+    /// Computes the BIP-0143 sighash to spend a p2wpkh transaction for any flag type.
     ///
     /// `script_pubkey` is the `scriptPubkey` (native SegWit) of the spend transaction
     /// ([`TxOut::script_pubkey`]) or the `redeemScript` (wrapped SegWit).
-    pub fn p2wpkh_signature_hash(
+    pub fn p2wpkh_signature_hash<T: ScriptHashableTag>(
         &mut self,
         input_index: usize,
-        script_pubkey: &Script,
-        value: Amount,
+        script_pubkey: &crate::script::Script<T>,
+        amount: Amount,
         sighash_type: EcdsaSighashType,
     ) -> Result<SegwitV0Sighash, P2wpkhError> {
         let script_code = script_pubkey.p2wpkh_script_code().ok_or(P2wpkhError::NotP2wpkhScript)?;
@@ -886,22 +886,22 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             &mut enc,
             input_index,
             &script_code,
-            value,
+            amount,
             sighash_type,
         )
         .map_err(SigningDataError::unwrap_sighash)?;
         Ok(SegwitV0Sighash::from_engine(enc))
     }
 
-    /// Computes the BIP143 sighash to spend a p2wsh transaction for any flag type.
+    /// Computes the BIP-0143 sighash to spend a p2wsh transaction for any flag type.
     ///
     /// `witness_script` is the script that goes into the [`Witness`],
     /// not the one that goes into `script_pubkey` of a [`TxOut`].
     pub fn p2wsh_signature_hash(
         &mut self,
         input_index: usize,
-        witness_script: &Script,
-        value: Amount,
+        witness_script: &WitnessScript,
+        amount: Amount,
         sighash_type: EcdsaSighashType,
     ) -> Result<SegwitV0Sighash, transaction::InputsIndexError> {
         let mut enc = SegwitV0Sighash::engine();
@@ -909,7 +909,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             &mut enc,
             input_index,
             witness_script,
-            value,
+            amount,
             sighash_type,
         )
         .map_err(SigningDataError::unwrap_sighash)?;
@@ -938,11 +938,11 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
     ///
     /// This function can't handle the SIGHASH_SINGLE bug internally, so it returns [`EncodeSigningDataResult`]
     /// that must be handled by the caller (see [`EncodeSigningDataResult::is_sighash_single_bug`]).
-    pub fn legacy_encode_signing_data_to<W: Write + ?Sized, U: Into<u32>>(
+    pub fn legacy_encode_signing_data_to<W: Write + ?Sized, U: Into<u32>, T: ScriptHashableTag>(
         &self,
         writer: &mut W,
         input_index: usize,
-        script_pubkey: &Script,
+        script_pubkey: &crate::script::Script<T>,
         sighash_type: U,
     ) -> EncodeSigningDataResult<SigningDataError<transaction::InputsIndexError>> {
         // Validate input_index.
@@ -954,7 +954,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         if is_invalid_use_of_sighash_single(
             sighash_type,
             input_index,
-            self.tx.borrow().output.len(),
+            self.tx.borrow().outputs.len(),
         ) {
             // We cannot correctly handle the SIGHASH_SINGLE bug here because usage of this function
             // will result in the data written to the writer being hashed, however the correct
@@ -963,11 +963,11 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             return EncodeSigningDataResult::SighashSingleBug;
         }
 
-        fn encode_signing_data_to_inner<W: Write + ?Sized>(
+        fn encode_signing_data_to_inner<W: Write + ?Sized, T: ScriptHashableTag>(
             self_: &Transaction,
             writer: &mut W,
             input_index: usize,
-            script_pubkey: &Script,
+            script_pubkey: &crate::script::Script<T>,
             sighash_type: u32,
         ) -> Result<(), io::Error> {
             use crate::consensus::encode::WriteExt;
@@ -979,17 +979,17 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             // Add all inputs necessary..
             if anyone_can_pay {
                 writer.emit_compact_size(1u8)?;
-                self_.input[input_index].previous_output.consensus_encode(writer)?;
+                self_.inputs[input_index].previous_output.consensus_encode(writer)?;
                 script_pubkey.consensus_encode(writer)?;
-                self_.input[input_index].sequence.consensus_encode(writer)?;
+                self_.inputs[input_index].sequence.consensus_encode(writer)?;
             } else {
-                writer.emit_compact_size(self_.input.len())?;
-                for (n, input) in self_.input.iter().enumerate() {
+                writer.emit_compact_size(self_.inputs.len())?;
+                for (n, input) in self_.inputs.iter().enumerate() {
                     input.previous_output.consensus_encode(writer)?;
                     if n == input_index {
                         script_pubkey.consensus_encode(writer)?;
                     } else {
-                        Script::new().consensus_encode(writer)?;
+                        ScriptPubKey::new().consensus_encode(writer)?;
                     }
                     if n != input_index
                         && (sighash == EcdsaSighashType::Single
@@ -1004,19 +1004,19 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             // ..then all outputs
             match sighash {
                 EcdsaSighashType::All => {
-                    self_.output.consensus_encode(writer)?;
+                    self_.outputs.consensus_encode(writer)?;
                 }
                 EcdsaSighashType::Single => {
                     // sign all outputs up to and including this one, but erase
                     // all of them except for this one
-                    let count = input_index.min(self_.output.len() - 1);
+                    let count = input_index.min(self_.outputs.len() - 1);
                     writer.emit_compact_size(count + 1)?;
                     for _ in 0..count {
                         // consensus encoding of the "NULL txout" - max amount, empty script_pubkey
                         writer
                             .write_all(&[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00])?;
                     }
-                    self_.output[count].consensus_encode(writer)?;
+                    self_.outputs[count].consensus_encode(writer)?;
                 }
                 EcdsaSighashType::None => {
                     writer.emit_compact_size(0u8)?;
@@ -1059,10 +1059,10 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
     /// Does NOT attempt to support OP_CODESEPARATOR. In general this would require evaluating
     /// `script_pubkey` to determine which separators get evaluated and which don't, which we don't
     /// have the information to determine.
-    pub fn legacy_signature_hash(
+    pub fn legacy_signature_hash<T: ScriptHashableTag>(
         &self,
         input_index: usize,
-        script_pubkey: &Script,
+        script_pubkey: &crate::script::Script<T>,
         sighash_type: u32,
     ) -> Result<LegacySighash, transaction::InputsIndexError> {
         let mut engine = LegacySighash::engine();
@@ -1088,7 +1088,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
         common_cache.get_or_insert_with(|| {
             let mut enc_prevouts = sha256::Hash::engine();
             let mut enc_sequences = sha256::Hash::engine();
-            for txin in tx.input.iter() {
+            for txin in tx.inputs.iter() {
                 txin.previous_output.consensus_encode(&mut enc_prevouts).unwrap();
                 txin.sequence.consensus_encode(&mut enc_sequences).unwrap();
             }
@@ -1097,7 +1097,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
                 sequences: sha256::Hash::from_engine(enc_sequences),
                 outputs: {
                     let mut enc = sha256::Hash::engine();
-                    for txout in tx.output.iter() {
+                    for txout in tx.outputs.iter() {
                         txout.consensus_encode(&mut enc).unwrap();
                     }
                     sha256::Hash::from_engine(enc)
@@ -1124,7 +1124,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             let mut enc_amounts = sha256::Hash::engine();
             let mut enc_script_pubkeys = sha256::Hash::engine();
             for prevout in prevouts {
-                prevout.borrow().value.consensus_encode(&mut enc_amounts).unwrap();
+                prevout.borrow().amount.consensus_encode(&mut enc_amounts).unwrap();
                 prevout.borrow().script_pubkey.consensus_encode(&mut enc_script_pubkeys).unwrap();
             }
             TaprootCache {
@@ -1166,7 +1166,7 @@ impl<R: BorrowMut<Transaction>> SighashCache<R> {
     /// [`SegWit v0`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/sign-tx-segwit-v0.rs>
     /// [`taproot`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/sign-tx-taproot.rs>
     pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Witness> {
-        self.tx.borrow_mut().input.get_mut(input_index).map(|i| &mut i.witness)
+        self.tx.borrow_mut().inputs.get_mut(input_index).map(|i| &mut i.witness)
     }
 }
 
@@ -1177,12 +1177,10 @@ pub struct Annex<'a>(&'a [u8]);
 impl<'a> Annex<'a> {
     /// Constructs a new `Annex` struct checking the first byte is `0x50`.
     pub fn new(annex_bytes: &'a [u8]) -> Result<Self, AnnexError> {
-        use AnnexError::*;
-
         match annex_bytes.first() {
             Some(&TAPROOT_ANNEX_PREFIX) => Ok(Annex(annex_bytes)),
-            Some(other) => Err(IncorrectPrefix(*other)),
-            None => Err(Empty),
+            Some(other) => Err(AnnexError::IncorrectPrefix(*other)),
+            None => Err(AnnexError::Empty),
         }
     }
 
@@ -1202,7 +1200,7 @@ impl Encodable for Annex<'_> {
 pub enum TaprootError {
     /// Index out of bounds when accessing transaction input vector.
     InputsIndex(transaction::InputsIndexError),
-    /// Using `SIGHASH_SINGLE` requires an output at the same index is the input.
+    /// Using `SIGHASH_SINGLE` requires an output at the same index as the input.
     SingleMissingOutput(SingleMissingOutputError),
     /// Prevouts size error.
     PrevoutsSize(PrevoutsSizeError),
@@ -1220,15 +1218,14 @@ impl From<Infallible> for TaprootError {
 
 impl fmt::Display for TaprootError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use TaprootError::*;
-
-        match *self {
-            InputsIndex(ref e) => write_err!(f, "inputs index"; e),
-            SingleMissingOutput(ref e) => write_err!(f, "sighash single"; e),
-            PrevoutsSize(ref e) => write_err!(f, "prevouts size"; e),
-            PrevoutsIndex(ref e) => write_err!(f, "prevouts index"; e),
-            PrevoutsKind(ref e) => write_err!(f, "prevouts kind"; e),
-            InvalidSighashType(hash_ty) => write!(f, "invalid Taproot sighash type : {} ", hash_ty),
+        match self {
+            Self::InputsIndex(ref e) => write_err!(f, "inputs index"; e),
+            Self::SingleMissingOutput(ref e) => write_err!(f, "sighash single"; e),
+            Self::PrevoutsSize(ref e) => write_err!(f, "prevouts size"; e),
+            Self::PrevoutsIndex(ref e) => write_err!(f, "prevouts index"; e),
+            Self::PrevoutsKind(ref e) => write_err!(f, "prevouts kind"; e),
+            Self::InvalidSighashType(hash_ty) =>
+                write!(f, "invalid Taproot sighash type : {} ", hash_ty),
         }
     }
 }
@@ -1236,15 +1233,13 @@ impl fmt::Display for TaprootError {
 #[cfg(feature = "std")]
 impl std::error::Error for TaprootError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use TaprootError::*;
-
-        match *self {
-            InputsIndex(ref e) => Some(e),
-            SingleMissingOutput(ref e) => Some(e),
-            PrevoutsSize(ref e) => Some(e),
-            PrevoutsIndex(ref e) => Some(e),
-            PrevoutsKind(ref e) => Some(e),
-            InvalidSighashType(_) => None,
+        match self {
+            Self::InputsIndex(ref e) => Some(e),
+            Self::SingleMissingOutput(ref e) => Some(e),
+            Self::PrevoutsSize(ref e) => Some(e),
+            Self::PrevoutsIndex(ref e) => Some(e),
+            Self::PrevoutsKind(ref e) => Some(e),
+            Self::InvalidSighashType(_) => None,
         }
     }
 }
@@ -1280,16 +1275,14 @@ impl From<Infallible> for P2wpkhError {
 }
 
 impl From<transaction::InputsIndexError> for P2wpkhError {
-    fn from(value: transaction::InputsIndexError) -> Self { P2wpkhError::Sighash(value) }
+    fn from(value: transaction::InputsIndexError) -> Self { Self::Sighash(value) }
 }
 
 impl fmt::Display for P2wpkhError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use P2wpkhError::*;
-
-        match *self {
-            Sighash(ref e) => write_err!(f, "error encoding SegWit v0 signing data"; e),
-            NotP2wpkhScript => write!(f, "script is not a script pubkey for a p2wpkh output"),
+        match self {
+            Self::Sighash(ref e) => write_err!(f, "error encoding SegWit v0 signing data"; e),
+            Self::NotP2wpkhScript => write!(f, "script is not a script pubkey for a p2wpkh output"),
         }
     }
 }
@@ -1297,11 +1290,9 @@ impl fmt::Display for P2wpkhError {
 #[cfg(feature = "std")]
 impl std::error::Error for P2wpkhError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use P2wpkhError::*;
-
-        match *self {
-            Sighash(ref e) => Some(e),
-            NotP2wpkhScript => None,
+        match self {
+            Self::Sighash(ref e) => Some(e),
+            Self::NotP2wpkhScript => None,
         }
     }
 }
@@ -1348,11 +1339,9 @@ impl From<Infallible> for AnnexError {
 
 impl fmt::Display for AnnexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use AnnexError::*;
-
-        match *self {
-            Empty => write!(f, "the annex is empty"),
-            IncorrectPrefix(byte) =>
+        match self {
+            Self::Empty => write!(f, "the annex is empty"),
+            Self::IncorrectPrefix(byte) =>
                 write!(f, "incorrect prefix byte in the annex {:02x}, expecting 0x50", byte),
         }
     }
@@ -1361,10 +1350,8 @@ impl fmt::Display for AnnexError {
 #[cfg(feature = "std")]
 impl std::error::Error for AnnexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use AnnexError::*;
-
-        match *self {
-            Empty | IncorrectPrefix(_) => None,
+        match self {
+            Self::Empty | Self::IncorrectPrefix(_) => None,
         }
     }
 }
@@ -1404,7 +1391,7 @@ impl<E> EncodeSigningDataResult<E> {
     /// # use bitcoin::Transaction;
     /// # let mut writer = sha256d::Hash::engine();
     /// # let input_index = 0;
-    /// # let script_pubkey = bitcoin::ScriptBuf::new();
+    /// # let script_pubkey = bitcoin::ScriptPubKeyBuf::new();
     /// # let sighash_u32 = 0u32;
     /// # const SOME_TX: &'static str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
     /// # let raw_tx = Vec::from_hex(SOME_TX).unwrap();
@@ -1421,9 +1408,9 @@ impl<E> EncodeSigningDataResult<E> {
     #[allow(clippy::wrong_self_convention)] // Consume self so we can take the error.
     pub fn is_sighash_single_bug(self) -> Result<bool, E> {
         match self {
-            EncodeSigningDataResult::SighashSingleBug => Ok(true),
-            EncodeSigningDataResult::WriteResult(Ok(())) => Ok(false),
-            EncodeSigningDataResult::WriteResult(Err(e)) => Err(e),
+            Self::SighashSingleBug => Ok(true),
+            Self::WriteResult(Ok(())) => Ok(false),
+            Self::WriteResult(Err(e)) => Err(e),
         }
     }
 
@@ -1436,11 +1423,9 @@ impl<E> EncodeSigningDataResult<E> {
         F: FnOnce(E) -> E2,
     {
         match self {
-            EncodeSigningDataResult::SighashSingleBug => EncodeSigningDataResult::SighashSingleBug,
-            EncodeSigningDataResult::WriteResult(Err(e)) =>
-                EncodeSigningDataResult::WriteResult(Err(f(e))),
-            EncodeSigningDataResult::WriteResult(Ok(o)) =>
-                EncodeSigningDataResult::WriteResult(Ok(o)),
+            Self::SighashSingleBug => EncodeSigningDataResult::SighashSingleBug,
+            Self::WriteResult(Err(e)) => EncodeSigningDataResult::WriteResult(Err(f(e))),
+            Self::WriteResult(Ok(o)) => EncodeSigningDataResult::WriteResult(Ok(o)),
         }
     }
 }
@@ -1492,8 +1477,8 @@ impl<E: fmt::Display> fmt::Display for SigningDataError<E> {
 impl<E: std::error::Error + 'static> std::error::Error for SigningDataError<E> {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            SigningDataError::Io(error) => Some(error),
-            SigningDataError::Sighash(error) => Some(error),
+            Self::Io(error) => Some(error),
+            Self::Sighash(error) => Some(error),
         }
     }
 }
@@ -1503,12 +1488,12 @@ impl<'a> Arbitrary<'a> for EcdsaSighashType {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=5)?;
         match choice {
-            0 => Ok(EcdsaSighashType::All),
-            1 => Ok(EcdsaSighashType::None),
-            2 => Ok(EcdsaSighashType::Single),
-            3 => Ok(EcdsaSighashType::AllPlusAnyoneCanPay),
-            4 => Ok(EcdsaSighashType::NonePlusAnyoneCanPay),
-            _ => Ok(EcdsaSighashType::SinglePlusAnyoneCanPay),
+            0 => Ok(Self::All),
+            1 => Ok(Self::None),
+            2 => Ok(Self::Single),
+            3 => Ok(Self::AllPlusAnyoneCanPay),
+            4 => Ok(Self::NonePlusAnyoneCanPay),
+            _ => Ok(Self::SinglePlusAnyoneCanPay),
         }
     }
 }
@@ -1518,13 +1503,13 @@ impl<'a> Arbitrary<'a> for TapSighashType {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=6)?;
         match choice {
-            0 => Ok(TapSighashType::Default),
-            1 => Ok(TapSighashType::All),
-            2 => Ok(TapSighashType::None),
-            3 => Ok(TapSighashType::Single),
-            4 => Ok(TapSighashType::AllPlusAnyoneCanPay),
-            5 => Ok(TapSighashType::NonePlusAnyoneCanPay),
-            _ => Ok(TapSighashType::SinglePlusAnyoneCanPay),
+            0 => Ok(Self::Default),
+            1 => Ok(Self::All),
+            2 => Ok(Self::None),
+            3 => Ok(Self::Single),
+            4 => Ok(Self::AllPlusAnyoneCanPay),
+            5 => Ok(Self::NonePlusAnyoneCanPay),
+            _ => Ok(Self::SinglePlusAnyoneCanPay),
         }
     }
 }
@@ -1538,12 +1523,14 @@ mod tests {
     use super::*;
     use crate::consensus::deserialize;
     use crate::locktime::absolute;
-    use crate::script::{ScriptBuf, ScriptBufExt as _};
+    use crate::script::{
+        ScriptBufExt as _, ScriptPubKey, ScriptPubKeyBuf, TapScriptBuf, WitnessScriptBuf,
+    };
     use crate::TxIn;
 
     extern crate serde_json;
 
-    const DUMMY_TXOUT: TxOut = TxOut { value: Amount::MIN, script_pubkey: ScriptBuf::new() };
+    const DUMMY_TXOUT: TxOut = TxOut { amount: Amount::MIN, script_pubkey: ScriptPubKeyBuf::new() };
 
     #[test]
     fn sighash_single_bug() {
@@ -1551,10 +1538,10 @@ mod tests {
         let tx = Transaction {
             version: transaction::Version::ONE,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
-            output: vec![DUMMY_TXOUT],
+            inputs: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
+            outputs: vec![DUMMY_TXOUT],
         };
-        let script = ScriptBuf::new();
+        let script = ScriptPubKeyBuf::new();
         let cache = SighashCache::new(&tx);
 
         let sighash_single = 3;
@@ -1584,7 +1571,7 @@ mod tests {
             expected_result: &str,
         ) {
             let tx: Transaction = deserialize(&Vec::from_hex(tx).unwrap()[..]).unwrap();
-            let script = ScriptBuf::from(Vec::from_hex(script).unwrap());
+            let script = ScriptPubKeyBuf::from(Vec::from_hex(script).unwrap());
             let mut raw_expected = Vec::from_hex(expected_result).unwrap();
             raw_expected.reverse();
             let bytes = <[u8; 32]>::try_from(&raw_expected[..]).unwrap();
@@ -1747,8 +1734,8 @@ mod tests {
         let dumb_tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![TxIn::EMPTY_COINBASE],
-            output: vec![],
+            inputs: vec![TxIn::EMPTY_COINBASE],
+            outputs: vec![],
         };
         let mut c = SighashCache::new(&dumb_tx);
 
@@ -1791,7 +1778,7 @@ mod tests {
             }))
         );
         assert_eq!(
-            c.legacy_signature_hash(10, Script::new(), 0u32),
+            c.legacy_signature_hash(10, ScriptPubKey::new(), 0u32),
             Err(InputsIndexError(IndexOutOfBoundsError {
                 index: 10,
                 length: 1
@@ -1832,7 +1819,7 @@ mod tests {
 
         let leaf_hash = match (script_hex, script_leaf_hash) {
             (Some(script_hex), _) => {
-                let script_inner = ScriptBuf::from_hex_no_length_prefix(script_hex).unwrap();
+                let script_inner = TapScriptBuf::from_hex_no_length_prefix(script_hex).unwrap();
                 Some(ScriptPath::with_defaults(&script_inner).leaf_hash())
             }
             (_, Some(script_leaf_hash)) => Some(script_leaf_hash.parse::<TapLeafHash>().unwrap()),
@@ -1887,10 +1874,10 @@ mod tests {
         #[derive(serde::Deserialize)]
         struct UtxoSpent {
             #[serde(rename = "scriptPubKey")]
-            script_pubkey: ScriptBuf,
+            script_pubkey: ScriptPubKeyBuf,
             #[serde(rename = "amountSats")]
             #[serde(with = "crate::amount::serde::as_sat")]
-            value: Amount,
+            amount: Amount,
         }
 
         #[derive(serde::Deserialize)]
@@ -1968,7 +1955,6 @@ mod tests {
             serde_json::from_str::<TestData>(json_str).expect("JSON was not well-formatted");
 
         assert_eq!(data.version, 1u64);
-        let secp = &secp256k1::Secp256k1::new();
         let key_path = data.key_path_spending.remove(0);
 
         let raw_unsigned_tx = key_path.given.raw_unsigned_tx;
@@ -1976,7 +1962,7 @@ mod tests {
             .given
             .utxos_spent
             .into_iter()
-            .map(|txo| TxOut { value: txo.value, script_pubkey: txo.script_pubkey })
+            .map(|txo| TxOut { amount: txo.amount, script_pubkey: txo.script_pubkey })
             .collect::<Vec<_>>();
 
         // Test intermediary
@@ -2007,10 +1993,10 @@ mod tests {
             };
 
             // tests
-            let keypair = secp256k1::Keypair::from_secret_key(secp, &internal_priv_key);
+            let keypair = secp256k1::Keypair::from_secret_key(&internal_priv_key);
             let (internal_key, _parity) = XOnlyPublicKey::from_keypair(&keypair);
             let tweak = TapTweakHash::from_key_and_merkle_root(internal_key, merkle_root);
-            let tweaked_keypair = keypair.add_xonly_tweak(secp, &tweak.to_scalar()).unwrap();
+            let tweaked_keypair = keypair.add_xonly_tweak(&tweak.to_scalar()).unwrap();
             let mut sig_msg = Vec::new();
             cache
                 .taproot_encode_signing_data_to(
@@ -2026,9 +2012,11 @@ mod tests {
                 .taproot_signature_hash(tx_ind, &Prevouts::All(&utxos), None, None, hash_ty)
                 .unwrap();
 
-            let msg = secp256k1::Message::from(sighash);
-            let key_spend_sig =
-                secp.sign_schnorr_with_aux_rand(msg.as_ref(), &tweaked_keypair, &[0u8; 32]);
+            let key_spend_sig = secp256k1::schnorr::sign_with_aux_rand(
+                &sighash.to_byte_array(),
+                &tweaked_keypair,
+                &[0u8; 32],
+            );
 
             assert_eq!(expected.internal_pubkey, internal_key);
             assert_eq!(expected.tweak, tweak);
@@ -2090,21 +2078,22 @@ mod tests {
             ),
         ).unwrap();
 
-        let spk =
-            ScriptBuf::from_hex_no_length_prefix("00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1")
-                .unwrap();
-        let value = Amount::from_sat_u32(600_000_000);
+        let spk = ScriptPubKeyBuf::from_hex_no_length_prefix(
+            "00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1",
+        )
+        .unwrap();
+        let amount = Amount::from_sat_u32(600_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
-            cache.p2wpkh_signature_hash(1, &spk, value, EcdsaSighashType::All).unwrap(),
+            cache.p2wpkh_signature_hash(1, &spk, amount, EcdsaSighashType::All).unwrap(),
             "c37af31116d1b27caf68aae9e3ac82f1477929014d5b917657d0eb49478cb670"
                 .parse::<SegwitV0Sighash>()
                 .unwrap(),
         );
 
         let cache = cache.segwit_cache();
-        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        // Parse hex into Vec because BIP-0143 test vector displays forwards but our sha256d::Hash displays backwards.
         assert_eq!(
             cache.prevouts.as_byte_array(),
             &Vec::from_hex("96b827c8483d4e9b96712b6713a7b68d6e8003a781feba36c31143470b4efd37")
@@ -2132,21 +2121,22 @@ mod tests {
             ),
         ).unwrap();
 
-        let redeem_script =
-            ScriptBuf::from_hex_no_length_prefix("001479091972186c449eb1ded22b78e40d009bdf0089")
-                .unwrap();
-        let value = Amount::from_sat_u32(1_000_000_000);
+        let spk = ScriptPubKeyBuf::from_hex_no_length_prefix(
+            "001479091972186c449eb1ded22b78e40d009bdf0089",
+        )
+        .unwrap();
+        let amount = Amount::from_sat_u32(1_000_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
-            cache.p2wpkh_signature_hash(0, &redeem_script, value, EcdsaSighashType::All).unwrap(),
+            cache.p2wpkh_signature_hash(0, &spk, amount, EcdsaSighashType::All).unwrap(),
             "64f3b0f4dd2bb3aa1ce8566d220cc74dda9df97d8490cc81d89d735c92e59fb6"
                 .parse::<SegwitV0Sighash>()
                 .unwrap(),
         );
 
         let cache = cache.segwit_cache();
-        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        // Parse hex into Vec because BIP-0143 test vector displays forwards but our sha256d::Hash displays backwards.
         assert_eq!(
             cache.prevouts.as_byte_array(),
             &Vec::from_hex("b0287b4a252ac05af83d2dcef00ba313af78a3e9c329afa216eb3aa2a7b4613a")
@@ -2164,10 +2154,10 @@ mod tests {
         );
     }
 
-    // Note, if you are looking at the test vectors in BIP-143 and wondering why there is a `cf`
+    // Note, if you are looking at the test vectors in BIP-0143 and wondering why there is a `cf`
     // prepended to all the script_code hex it is the length byte, it gets added when we consensus
     // encode a script.
-    fn bip143_p2wsh_nested_in_p2sh_data() -> (Transaction, ScriptBuf, Amount) {
+    fn bip143_p2wsh_nested_in_p2sh_data() -> (Transaction, WitnessScriptBuf, Amount) {
         let tx = deserialize::<Transaction>(&hex!(
             "010000000136641869ca081e70f394c6948e8af409e18b619df2ed74aa106c1ca29787b96e0100000000\
              ffffffff0200e9a435000000001976a914389ffce9cd9ae88dcc0631e88a821ffdbe9bfe2688acc0832f\
@@ -2175,7 +2165,7 @@ mod tests {
         ))
         .unwrap();
 
-        let witness_script = ScriptBuf::from_hex_no_length_prefix(
+        let witness_script = WitnessScriptBuf::from_hex_no_length_prefix(
             "56210307b8ae49ac90a048e9b53357a2354b3334e9c8bee813ecb98e99a7e07e8c3ba32103b28f0c28\
              bfab54554ae8c658ac5c3e0ce6e79ad336331f78c428dd43eea8449b21034b8113d703413d57761b8b\
              9781957b8c0ac1dfe69f492580ca4195f50376ba4a21033400f6afecb833092a9a21cfdf1ed1376e58\
@@ -2185,16 +2175,16 @@ mod tests {
         )
         .unwrap();
 
-        let value = Amount::from_sat_u32(987_654_321);
-        (tx, witness_script, value)
+        let amount = Amount::from_sat_u32(987_654_321);
+        (tx, witness_script, amount)
     }
 
     #[test]
     fn bip143_p2wsh_nested_in_p2sh_sighash_type_all() {
-        let (tx, witness_script, value) = bip143_p2wsh_nested_in_p2sh_data();
+        let (tx, witness_script, amount) = bip143_p2wsh_nested_in_p2sh_data();
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
-            cache.p2wsh_signature_hash(0, &witness_script, value, EcdsaSighashType::All).unwrap(),
+            cache.p2wsh_signature_hash(0, &witness_script, amount, EcdsaSighashType::All).unwrap(),
             "185c0be5263dce5b4bb50a047973c1b6272bfbd0103a89444597dc40b248ee7c"
                 .parse::<SegwitV0Sighash>()
                 .unwrap(),
@@ -2206,7 +2196,7 @@ mod tests {
         // sighash for all sighash types.
 
         let cache = cache.segwit_cache();
-        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        // Parse hex into Vec because BIP-0143 test vector displays forwards but our sha256d::Hash displays backwards.
         assert_eq!(
             cache.prevouts.as_byte_array(),
             &Vec::from_hex("74afdc312af5183c4198a40ca3c1a275b485496dd3929bca388c4b5e31f7aaa0")
@@ -2231,11 +2221,11 @@ mod tests {
                 fn $test_name() {
                     use EcdsaSighashType::*;
 
-                    let (tx, witness_script, value) = bip143_p2wsh_nested_in_p2sh_data();
+                    let (tx, witness_script, amount) = bip143_p2wsh_nested_in_p2sh_data();
                     let mut cache = SighashCache::new(&tx);
                     assert_eq!(
                         cache
-                            .p2wsh_signature_hash(0, &witness_script, value, $sighash_type)
+                            .p2wsh_signature_hash(0, &witness_script, amount, $sighash_type)
                             .unwrap(),
                         $sighash
                             .parse::<SegwitV0Sighash>()
diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index e8dfa2ee97..c1e1abf995 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -1,23 +1,27 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Bitcoin Taproot keys.
+//! Bitcoin Taproot signatures.
 //!
-//! This module provides Taproot keys used in Bitcoin (including reexporting secp256k1 keys).
+//! This module provides Taproot signatures used by Bitcoin that can be roundtrip (de)serialized.
 
+use core::borrow::Borrow;
 use core::convert::Infallible;
 use core::fmt;
+use core::ops::Deref;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use internals::array::ArrayExt;
-use internals::write_err;
+use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::Write;
 
-use crate::prelude::Vec;
+pub use self::into_iter::IntoIter;
+use crate::prelude::{DisplayHex, Vec};
 use crate::sighash::{InvalidSighashTypeError, TapSighashType};
-use crate::taproot::serialized_signature::{self, SerializedSignature};
 
-/// A BIP340-341 serialized Taproot signature with the corresponding hash type.
+const MAX_LEN: usize = 65; // 64 for sig, 1B sighash flag
+
+/// A BIP-0340-0341 serialized Taproot signature with the corresponding hash type.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Signature {
@@ -33,17 +37,35 @@ impl Signature {
         if let Ok(signature) = <[u8; 64]>::try_from(sl) {
             // default type
             let signature = secp256k1::schnorr::Signature::from_byte_array(signature);
-            Ok(Signature { signature, sighash_type: TapSighashType::Default })
+            Ok(Self { signature, sighash_type: TapSighashType::Default })
         } else if let Ok(signature) = <[u8; 65]>::try_from(sl) {
             let (sighash_type, signature) = signature.split_last();
             let sighash_type = TapSighashType::from_consensus_u8(*sighash_type)?;
             let signature = secp256k1::schnorr::Signature::from_byte_array(*signature);
-            Ok(Signature { signature, sighash_type })
+            Ok(Self { signature, sighash_type })
         } else {
             Err(SigFromSliceError::InvalidSignatureSize(sl.len()))
         }
     }
 
+    /// Serializes the signature (without heap allocation).
+    ///
+    /// This returns a type with an API very similar to that of `Box<[u8]>`.
+    /// You can get a slice from it using deref coercions or turn it into an iterator.
+    pub fn serialize(self) -> SerializedSignature {
+        let mut buf = [0; MAX_LEN];
+        let ser_sig = self.signature.to_byte_array();
+        buf[..64].copy_from_slice(&ser_sig);
+        let len = if self.sighash_type == TapSighashType::Default {
+            // default sighash type, don't add extra sighash byte
+            64
+        } else {
+            buf[64] = self.sighash_type as u8;
+            65
+        };
+        SerializedSignature::from_raw_parts(buf, len)
+    }
+
     /// Serializes the signature.
     ///
     /// Note: this allocates on the heap, prefer [`serialize`](Self::serialize) if vec is not needed.
@@ -62,23 +84,273 @@ impl Signature {
         let sig = self.serialize();
         sig.write_to(writer)
     }
+}
 
-    /// Serializes the signature (without heap allocation).
+/// A serialized Taproot Signature
+///
+/// Serialized Taproot signatures have the issue that they can have different lengths.
+/// We want to avoid using `Vec` since that would require allocations making the code slower and
+/// unable to run on platforms without an allocator.
+#[derive(Copy, Clone)]
+pub struct SerializedSignature {
+    data: [u8; MAX_LEN],
+    len: usize,
+}
+
+impl SerializedSignature {
+    /// Constructs a new SerializedSignature from a Signature.
     ///
-    /// This returns a type with an API very similar to that of `Box<[u8]>`.
-    /// You can get a slice from it using deref coercions or turn it into an iterator.
-    pub fn serialize(self) -> SerializedSignature {
-        let mut buf = [0; serialized_signature::MAX_LEN];
-        let ser_sig = self.signature.to_byte_array();
-        buf[..64].copy_from_slice(&ser_sig);
-        let len = if self.sighash_type == TapSighashType::Default {
-            // default sighash type, don't add extra sighash byte
-            64
-        } else {
-            buf[64] = self.sighash_type as u8;
-            65
-        };
-        SerializedSignature::from_raw_parts(buf, len)
+    /// In other words this serializes a `Signature` into a `SerializedSignature`.
+    #[inline]
+    pub fn from_signature(sig: Signature) -> Self { sig.serialize() }
+
+    /// Converts the serialized signature into the [`Signature`] struct.
+    ///
+    /// In other words this deserializes the `SerializedSignature`.
+    #[inline]
+    pub fn to_signature(self) -> Result<Signature, SigFromSliceError> {
+        Signature::from_slice(&self)
+    }
+
+    /// Returns the length of the serialized signature data.
+    #[inline]
+    // `len` is never 0, so `is_empty` would always return `false`.
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize { self.len }
+
+    /// Returns an iterator over bytes of the signature.
+    #[inline]
+    pub fn iter(&self) -> core::slice::Iter<'_, u8> { self.into_iter() }
+
+    /// Writes this serialized signature to a `writer`.
+    #[inline]
+    pub fn write_to<W: Write + ?Sized>(&self, writer: &mut W) -> Result<(), io::Error> {
+        writer.write_all(self)
+    }
+
+    /// Constructs new `SerializedSignature` from data and length.
+    ///
+    /// # Panics
+    ///
+    /// If `len` > `MAX_LEN`
+    #[inline]
+    pub(crate) fn from_raw_parts(data: [u8; MAX_LEN], len: usize) -> Self {
+        assert!(len <= MAX_LEN, "attempt to set length to {} but the maximum is {}", len, MAX_LEN);
+        Self { data, len }
+    }
+
+    /// Set the length of the object.
+    #[inline]
+    pub(crate) fn set_len_unchecked(&mut self, len: usize) { self.len = len; }
+}
+
+impl fmt::Debug for SerializedSignature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self, f) }
+}
+
+impl fmt::Display for SerializedSignature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        hex::fmt_hex_exact!(f, MAX_LEN, self, hex::Case::Lower)
+    }
+}
+
+impl fmt::LowerHex for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&(**self).as_hex(), f)
+    }
+}
+impl_to_hex_from_lower_hex!(SerializedSignature, |signature: &SerializedSignature| signature.len
+    * 2);
+
+impl fmt::UpperHex for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&(**self).as_hex(), f)
+    }
+}
+
+impl PartialEq for SerializedSignature {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool { **self == **other }
+}
+
+impl PartialEq<[u8]> for SerializedSignature {
+    #[inline]
+    fn eq(&self, other: &[u8]) -> bool { **self == *other }
+}
+
+impl PartialEq<SerializedSignature> for [u8] {
+    #[inline]
+    fn eq(&self, other: &SerializedSignature) -> bool { *self == **other }
+}
+
+impl PartialOrd for SerializedSignature {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { Some(self.cmp(other)) }
+}
+
+impl Ord for SerializedSignature {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering { (**self).cmp(&**other) }
+}
+
+impl PartialOrd<[u8]> for SerializedSignature {
+    fn partial_cmp(&self, other: &[u8]) -> Option<core::cmp::Ordering> {
+        (**self).partial_cmp(other)
+    }
+}
+
+impl PartialOrd<SerializedSignature> for [u8] {
+    fn partial_cmp(&self, other: &SerializedSignature) -> Option<core::cmp::Ordering> {
+        self.partial_cmp(&**other)
+    }
+}
+
+impl Eq for SerializedSignature {}
+
+impl core::hash::Hash for SerializedSignature {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) { (**self).hash(state) }
+}
+
+impl AsRef<[u8]> for SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &[u8] { &self.data[..self.len] }
+}
+
+impl Borrow<[u8]> for SerializedSignature {
+    #[inline]
+    fn borrow(&self) -> &[u8] { &self.data[..self.len] }
+}
+
+impl Deref for SerializedSignature {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] { &self.data[..self.len] }
+}
+
+impl IntoIterator for SerializedSignature {
+    type IntoIter = IntoIter;
+    type Item = u8;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { IntoIter::new(self) }
+}
+
+impl<'a> IntoIterator for &'a SerializedSignature {
+    type IntoIter = core::slice::Iter<'a, u8>;
+    type Item = &'a u8;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { (**self).iter() }
+}
+
+impl From<Signature> for SerializedSignature {
+    fn from(value: Signature) -> Self { Self::from_signature(value) }
+}
+
+impl<'a> From<&'a Signature> for SerializedSignature {
+    fn from(value: &'a Signature) -> Self { Self::from_signature(*value) }
+}
+
+impl TryFrom<SerializedSignature> for Signature {
+    type Error = SigFromSliceError;
+
+    fn try_from(value: SerializedSignature) -> Result<Self, Self::Error> { value.to_signature() }
+}
+
+impl<'a> TryFrom<&'a SerializedSignature> for Signature {
+    type Error = SigFromSliceError;
+
+    fn try_from(value: &'a SerializedSignature) -> Result<Self, Self::Error> {
+        value.to_signature()
+    }
+}
+
+/// Separate mod to prevent outside code from accidentally breaking invariants.
+mod into_iter {
+    use super::*;
+
+    /// Owned iterator over the bytes of [`SerializedSignature`]
+    ///
+    /// Created by [`IntoIterator::into_iter`] method.
+    // allowed because of https://github.com/rust-lang/rust/issues/98348
+    #[allow(missing_copy_implementations)]
+    #[derive(Debug, Clone)]
+    pub struct IntoIter {
+        signature: SerializedSignature,
+        // invariant: pos <= signature.len()
+        pos: usize,
+    }
+
+    impl IntoIter {
+        #[inline]
+        pub(crate) fn new(signature: SerializedSignature) -> Self {
+            Self {
+                signature,
+                // for all unsigned n: 0 <= n
+                pos: 0,
+            }
+        }
+
+        /// Returns the remaining bytes as a slice.
+        ///
+        /// This method is analogous to [`core::slice::Iter::as_slice`].
+        #[inline]
+        pub fn as_slice(&self) -> &[u8] { &self.signature[self.pos..] }
+    }
+
+    impl Iterator for IntoIter {
+        type Item = u8;
+
+        #[inline]
+        fn next(&mut self) -> Option<Self::Item> {
+            let byte = *self.signature.get(self.pos)?;
+            // can't overflow or break invariant because if pos is too large we return early
+            self.pos += 1;
+            Some(byte)
+        }
+
+        #[inline]
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            // can't overflow thanks to the invariant
+            let len = self.signature.len() - self.pos;
+            (len, Some(len))
+        }
+
+        // override for speed
+        #[inline]
+        fn nth(&mut self, n: usize) -> Option<Self::Item> {
+            if n >= self.len() {
+                // upholds invariant because the values will be equal
+                self.pos = self.signature.len();
+                None
+            } else {
+                // if n < signature.len() - self.pos then n + self.pos < signature.len() which neither
+                // overflows nor breaks the invariant
+                self.pos += n;
+                self.next()
+            }
+        }
+    }
+
+    impl ExactSizeIterator for IntoIter {}
+
+    impl core::iter::FusedIterator for IntoIter {}
+
+    impl DoubleEndedIterator for IntoIter {
+        #[inline]
+        fn next_back(&mut self) -> Option<Self::Item> {
+            if self.pos == self.signature.len() {
+                return None;
+            }
+
+            // if len is 0 then pos is also 0 thanks to the invariant so we would return before we
+            // reach this
+            let new_len = self.signature.len() - 1;
+            let byte = self.signature[new_len];
+            self.signature.set_len_unchecked(new_len);
+            Some(byte)
+        }
     }
 }
 
@@ -102,12 +374,10 @@ impl From<Infallible> for SigFromSliceError {
 
 impl fmt::Display for SigFromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use SigFromSliceError::*;
-
-        match *self {
-            SighashType(ref e) => write_err!(f, "sighash"; e),
-            Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
-            InvalidSignatureSize(sz) => write!(f, "invalid Taproot signature size: {}", sz),
+        match self {
+            Self::SighashType(ref e) => write_err!(f, "sighash"; e),
+            Self::Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
+            Self::InvalidSignatureSize(sz) => write!(f, "invalid Taproot signature size: {}", sz),
         }
     }
 }
@@ -115,12 +385,10 @@ impl fmt::Display for SigFromSliceError {
 #[cfg(feature = "std")]
 impl std::error::Error for SigFromSliceError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use SigFromSliceError::*;
-
-        match *self {
-            Secp256k1(ref e) => Some(e),
-            SighashType(ref e) => Some(e),
-            InvalidSignatureSize(_) => None,
+        match self {
+            Self::Secp256k1(ref e) => Some(e),
+            Self::SighashType(ref e) => Some(e),
+            Self::InvalidSignatureSize(_) => None,
         }
     }
 }
@@ -138,9 +406,45 @@ impl<'a> Arbitrary<'a> for Signature {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let arbitrary_bytes: [u8; secp256k1::constants::SCHNORR_SIGNATURE_SIZE] = u.arbitrary()?;
 
-        Ok(Signature {
+        Ok(Self {
             signature: secp256k1::schnorr::Signature::from_byte_array(arbitrary_bytes),
             sighash_type: TapSighashType::arbitrary(u)?,
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{SerializedSignature, MAX_LEN};
+
+    #[test]
+    fn iterator_ops_are_homomorphic() {
+        let mut fake_signature_data = [0; MAX_LEN];
+        for (i, byte) in fake_signature_data.iter_mut().enumerate() {
+            *byte = i as u8;
+        }
+
+        let fake_signature = SerializedSignature { data: fake_signature_data, len: MAX_LEN };
+
+        let mut iter1 = fake_signature.into_iter();
+        let mut iter2 = fake_signature.iter();
+
+        // while let so we can compare size_hint and as_slice
+        while let (Some(a), Some(b)) = (iter1.next(), iter2.next()) {
+            assert_eq!(a, *b);
+            assert_eq!(iter1.size_hint(), iter2.size_hint());
+            assert_eq!(iter1.as_slice(), iter2.as_slice());
+        }
+
+        let mut iter1 = fake_signature.into_iter();
+        let mut iter2 = fake_signature.iter();
+
+        // manual next_back instead of rev() so that we can check as_slice()
+        // if next_back is implemented correctly then rev() is also correct - provided by `core`
+        while let (Some(a), Some(b)) = (iter1.next_back(), iter2.next_back()) {
+            assert_eq!(a, *b);
+            assert_eq!(iter1.size_hint(), iter2.size_hint());
+            assert_eq!(iter1.as_slice(), iter2.as_slice());
+        }
+    }
+}
diff --git a/bitcoin/src/hash_types.rs b/bitcoin/src/hash_types.rs
index 296e1f1355..00aac645bb 100644
--- a/bitcoin/src/hash_types.rs
+++ b/bitcoin/src/hash_types.rs
@@ -4,8 +4,6 @@
 //!
 //! This module is deprecated. You can find hash types in their respective, hopefully obvious, modules.
 
-#[deprecated(since = "TBD", note = "use `crate::T` instead")]
-pub use crate::bip158::{FilterHash, FilterHeader};
 #[deprecated(since = "TBD", note = "use `crate::T` instead")]
 pub use crate::{BlockHash, TxMerkleNode, Txid, WitnessCommitment, WitnessMerkleNode, Wtxid};
 
@@ -92,14 +90,5 @@ mod tests {
             XKeyIdentifier::from_byte_array(DUMMY20).to_string(),
             "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb",
         );
-
-        assert_eq!(
-            FilterHash::from_byte_array(DUMMY32).to_string(),
-            "56944c5d3f98413ef45cf54545538103cc9f298e0575820ad3591376e2e0f65d",
-        );
-        assert_eq!(
-            FilterHeader::from_byte_array(DUMMY32).to_string(),
-            "56944c5d3f98413ef45cf54545538103cc9f298e0575820ad3591376e2e0f65d",
-        );
     }
 }
diff --git a/bitcoin/src/internal_macros.rs b/bitcoin/src/internal_macros.rs
index 69cbfcc2ae..190a2b71cb 100644
--- a/bitcoin/src/internal_macros.rs
+++ b/bitcoin/src/internal_macros.rs
@@ -33,7 +33,7 @@ macro_rules! impl_consensus_encoding {
             fn consensus_decode<R: $crate::io::BufRead + ?Sized>(
                 r: &mut R,
             ) -> core::result::Result<$thing, $crate::consensus::encode::Error> {
-                let mut r = r.take(internals::ToU64::to_u64($crate::consensus::encode::MAX_VEC_SIZE));
+                let mut r = $crate::io::Read::take(r, internals::ToU64::to_u64($crate::consensus::encode::MAX_VEC_SIZE));
                 Ok($thing {
                     $($field: $crate::consensus::Decodable::consensus_decode(&mut r)?),+
                 })
@@ -174,24 +174,6 @@ macro_rules! impl_array_newtype_stringify {
 }
 pub(crate) use impl_array_newtype_stringify;
 
-#[rustfmt::skip]
-macro_rules! impl_hashencode {
-    ($hashtype:ident) => {
-        impl $crate::consensus::Encodable for $hashtype {
-            fn consensus_encode<W: $crate::io::Write + ?Sized>(&self, w: &mut W) -> core::result::Result<usize, $crate::io::Error> {
-                self.as_byte_array().consensus_encode(w)
-            }
-        }
-
-        impl $crate::consensus::Decodable for $hashtype {
-            fn consensus_decode<R: $crate::io::BufRead + ?Sized>(r: &mut R) -> core::result::Result<Self, $crate::consensus::encode::Error> {
-                Ok(Self::from_byte_array(<<$hashtype as $crate::hashes::Hash>::Bytes>::consensus_decode(r)?))
-            }
-        }
-    };
-}
-pub(crate) use impl_hashencode;
-
 #[rustfmt::skip]
 macro_rules! impl_asref_push_bytes {
     ($($hashtype:ident),*) => {
@@ -246,30 +228,30 @@ pub(crate) use only_non_doc_attrs;
 
 /// Defines a trait `$trait_name` and implements it for `ty`, used to define extension traits.
 macro_rules! define_extension_trait {
-    ($(#[$($trait_attrs:tt)*])* $trait_vis:vis trait $trait_name:ident impl for $ty:ident {
+    ($(#[$($trait_attrs:tt)*])* $trait_vis:vis trait $trait_name:ident$(<$traitgen:ident $(= $traitdefault:ty)?>)? impl$(<$implgen:ident $(= $impldefault:ty)?>)? for $ty:ident$(<$tygen:ident $(= $tydefault:ty)?>)? {
         $(
             $(#[$($fn_attrs:tt)*])*
-            fn $fn:ident$(<$($gen:ident: $gent:path),*>)?($($params:tt)*) $( -> $ret:ty )? $body:block
+            fn $fn:ident$(<$($gen:ident: $gent:path),*>)?($($params:tt)*) $( -> $ret:ty )? $(where $wherety:ident $(= $whereeq:ident)? $(: $wherebound:ident)?)? $body:block
         )*
     }) => {
         #[cfg_attr(docsrs, doc(notable_trait))]
-        $(#[$($trait_attrs)*])* $trait_vis trait $trait_name: sealed::Sealed {
+        $(#[$($trait_attrs)*])* $trait_vis trait $trait_name$(<$traitgen $(= $traitdefault)?>)?: sealed::Sealed {
             $(
                 $crate::internal_macros::only_doc_attrs! {
                     { $(#[$($fn_attrs)*])* },
                     {
-                        fn $fn$(<$($gen: $gent),*>)?($($params)*) $( -> $ret )?;
+                        fn $fn$(<$($gen: $gent),*>)?($($params)*) $( -> $ret)? $(where $wherety $(= $whereeq)? $(: $wherebound)?)?;
                     }
                 }
             )*
         }
 
-        impl $trait_name for $ty {
+        impl$(<$implgen $(= $impldefault)?>)? $trait_name$(<$traitgen $(= $traitdefault)?>)? for $ty$(<$tygen $(= $tydefault)?>)? {
             $(
                 $crate::internal_macros::only_non_doc_attrs! {
                     { $(#[$($fn_attrs)*])* },
                     {
-                        fn $fn$(<$($gen: $gent),*>)?($($params)*) $( -> $ret )? $body
+                        fn $fn$(<$($gen: $gent),*>)?($($params)*) $( -> $ret )? $(where $wherety $(= $whereeq)? $(: $wherebound)?)? $body
                     }
                 }
             )*
@@ -277,126 +259,3 @@ macro_rules! define_extension_trait {
     };
 }
 pub(crate) use define_extension_trait;
-
-/// Implements standard array methods for a given wrapper type.
-macro_rules! impl_array_newtype {
-    ($thing:ident, $ty:ty, $len:literal) => {
-        impl $thing {
-            /// Constructs a new `Self` by wrapping `bytes`.
-            #[inline]
-            pub fn from_byte_array(bytes: [u8; $len]) -> Self { Self(bytes) }
-
-            /// Returns a reference the underlying byte array.
-            #[inline]
-            pub fn as_byte_array(&self) -> &[u8; $len] { &self.0 }
-
-            /// Returns the underlying byte array.
-            #[inline]
-            pub fn to_byte_array(self) -> [u8; $len] {
-                // We rely on `Copy` being implemented for $thing so conversion
-                // methods use the correct Rust naming conventions.
-                fn check_copy<T: Copy>() {}
-                check_copy::<$thing>();
-
-                self.0
-            }
-
-            /// Copies the underlying bytes into a new `Vec`.
-            #[inline]
-            pub fn to_vec(self) -> alloc::vec::Vec<u8> { self.0.to_vec() }
-
-            /// Returns a slice of the underlying bytes.
-            #[inline]
-            pub fn as_bytes(&self) -> &[u8] { &self.0 }
-
-            /// Copies the underlying bytes into a new `Vec`.
-            #[inline]
-            #[deprecated(since = "TBD", note = "use to_vec instead")]
-            pub fn to_bytes(self) -> alloc::vec::Vec<u8> { self.to_vec() }
-
-            /// Converts the object to a raw pointer.
-            #[inline]
-            pub fn as_ptr(&self) -> *const $ty {
-                let &$thing(ref dat) = self;
-                dat.as_ptr()
-            }
-
-            /// Converts the object to a mutable raw pointer.
-            #[inline]
-            pub fn as_mut_ptr(&mut self) -> *mut $ty {
-                let &mut $thing(ref mut dat) = self;
-                dat.as_mut_ptr()
-            }
-
-            /// Returns the length of the object as an array.
-            #[inline]
-            pub fn len(&self) -> usize { $len }
-
-            /// Returns whether the object, as an array, is empty. Always false.
-            #[inline]
-            pub fn is_empty(&self) -> bool { false }
-        }
-
-        impl<'a> core::convert::From<[$ty; $len]> for $thing {
-            fn from(data: [$ty; $len]) -> Self { $thing(data) }
-        }
-
-        impl<'a> core::convert::From<&'a [$ty; $len]> for $thing {
-            fn from(data: &'a [$ty; $len]) -> Self { $thing(*data) }
-        }
-
-        impl<'a> core::convert::TryFrom<&'a [$ty]> for $thing {
-            type Error = core::array::TryFromSliceError;
-
-            fn try_from(data: &'a [$ty]) -> core::result::Result<Self, Self::Error> {
-                use core::convert::TryInto;
-
-                Ok($thing(data.try_into()?))
-            }
-        }
-
-        impl AsRef<[$ty; $len]> for $thing {
-            fn as_ref(&self) -> &[$ty; $len] { &self.0 }
-        }
-
-        impl AsMut<[$ty; $len]> for $thing {
-            fn as_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
-        }
-
-        impl AsRef<[$ty]> for $thing {
-            fn as_ref(&self) -> &[$ty] { &self.0 }
-        }
-
-        impl AsMut<[$ty]> for $thing {
-            fn as_mut(&mut self) -> &mut [$ty] { &mut self.0 }
-        }
-
-        impl core::borrow::Borrow<[$ty; $len]> for $thing {
-            fn borrow(&self) -> &[$ty; $len] { &self.0 }
-        }
-
-        impl core::borrow::BorrowMut<[$ty; $len]> for $thing {
-            fn borrow_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
-        }
-
-        // The following two are valid because `[T; N]: Borrow<[T]>`
-        impl core::borrow::Borrow<[$ty]> for $thing {
-            fn borrow(&self) -> &[$ty] { &self.0 }
-        }
-
-        impl core::borrow::BorrowMut<[$ty]> for $thing {
-            fn borrow_mut(&mut self) -> &mut [$ty] { &mut self.0 }
-        }
-
-        impl<I> core::ops::Index<I> for $thing
-        where
-            [$ty]: core::ops::Index<I>,
-        {
-            type Output = <[$ty] as core::ops::Index<I>>::Output;
-
-            #[inline]
-            fn index(&self, index: I) -> &Self::Output { &self.0[index] }
-        }
-    };
-}
-pub(crate) use impl_array_newtype;
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index a57ababdeb..525814a39b 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin Library
+//! Rust Bitcoin Library
 //!
 //! This is a library that supports the Bitcoin network protocol and associated primitives. It is
 //! designed for Rust programs built to work with the Bitcoin network.
@@ -17,7 +17,6 @@
 //! * `bitcoinconsensus` (dependency) - enables validating scripts and transactions.
 //! * `default` - enables `std` and `secp-recovery`.
 //! * `rand` (transitive dependency) - makes it more convenient to generate random values.
-//! * `rand-std` - same as `rand` but also enables `std` here and in `secp256k1`.
 //! * `serde` (dependency) - implements `serde`-based serialization and deserialization.
 //! * `secp-lowmemory` - optimizations for low-memory devices.
 //! * `secp-recovery` - enables calculating public key from a signature and message.
@@ -25,21 +24,18 @@
 
 #![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
 // Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(docsrs, feature(doc_notable_trait))]
-#![cfg_attr(bench, feature(test))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
 // Instead of littering the codebase for non-fuzzing and bench code just globally allow.
 #![cfg_attr(fuzzing, allow(dead_code, unused_imports))]
-#![cfg_attr(bench, allow(dead_code, unused_imports))]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
 #![allow(clippy::incompatible_msrv)] // Has FPs and we're testing it which is more reliable anyway.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 // We only support machines with index size of 4 bytes or more.
 //
@@ -56,9 +52,6 @@ internals::const_assert!(
     "platforms that have usize less than 32 bits are not supported"
 );
 
-#[cfg(bench)]
-extern crate test;
-
 #[macro_use]
 extern crate alloc;
 
@@ -81,9 +74,12 @@ pub extern crate hex;
 /// Re-export the `bitcoin-io` crate.
 pub extern crate io;
 
+/// Re-export the `primitives` crate.
+pub extern crate primitives;
+
 /// Re-export the `rust-secp256k1` crate.
 ///
-/// Rust wrapper library for Pieter Wuille's libsecp256k1. Implements ECDSA and BIP-340 signatures
+/// Rust wrapper library for Pieter Wuille's libsecp256k1. Implements ECDSA and BIP-0340 signatures
 /// for the SECG elliptic curve group secp256k1 and related utilities.
 pub extern crate secp256k1;
 
@@ -92,13 +88,37 @@ pub extern crate secp256k1;
 extern crate serde;
 
 mod internal_macros;
-#[cfg(feature = "serde")]
-mod serde_utils;
 
+pub mod ext {
+    //! Re-export all the extension traits so downstream can use wildcard imports.
+    //!
+    //! As part of stabilizing `primitives` and `units` we created a bunch of extension traits in
+    //! `rust-bitcoin` to hold all then API that we are not yet ready to stabilize. This module
+    //! re-exports all of them to improve ergonomics for users comfortable with wildcard imports.
+    //!
+    //! # Examples
+    //!
+    //! ```
+    //! # #![allow(unused_imports)] // Because that is what we are demoing.
+    //! // Wildcard import all of the extension crates.
+    //! use bitcoin::ext::*;
+    //!
+    //! // If, for some reason, you want the name to be in scope access it via the module. E.g.
+    //! use bitcoin::script::ScriptSigExt;
+    //! ```
+    #[rustfmt::skip] // Use terse custom grouping.
+    pub use crate::{
+        block::{BlockCheckedExt as _, HeaderExt as _},
+        pow::CompactTargetExt as _,
+        script::{ScriptExt as _, ScriptBufExt as _, TapScriptExt as _, ScriptPubKeyExt as _, ScriptPubKeyBufExt as _, WitnessScriptExt as _, ScriptSigExt as _},
+        transaction::{TxidExt as _, WtxidExt as _, OutPointExt as _, TxInExt as _, TxOutExt as _, TransactionExt as _},
+        witness::WitnessExt as _,
+    };
+    #[cfg(feature = "bitcoinconsensus")]
+    pub use crate::consensus_validation::{ScriptPubKeyExt as _, TransactionExt as _};
+}
 #[macro_use]
-pub mod p2p;
 pub mod address;
-pub mod bip152;
 pub mod bip158;
 pub mod bip32;
 pub mod blockdata;
@@ -121,23 +141,31 @@ pub mod taproot;
 #[doc(inline)]
 pub use primitives::{
     block::{
-        Block, BlockHash, Checked as BlockChecked, Header as BlockHeader,
-        Unchecked as BlockUnchecked, Validation as BlockValidation, Version as BlockVersion,
-        WitnessCommitment,
+        compute_merkle_root, compute_witness_root, Block, BlockHash, Checked as BlockChecked,
+        Header as BlockHeader, InvalidBlockError, Unchecked as BlockUnchecked,
+        Validation as BlockValidation, Version as BlockVersion, WitnessCommitment,
     },
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     pow::CompactTarget, // No `pow` module outside of `primitives`.
-    script::{Script, ScriptBuf},
-    sequence::{self, Sequence}, // No `sequence` module outside of `primitives`.
-    transaction::{OutPoint, Transaction, TxIn, TxOut, Txid, Version as TransactionVersion, Wtxid},
+    script::{
+        RedeemScript, RedeemScriptBuf, RedeemScriptTag, ScriptHashableTag, ScriptPubKey,
+        ScriptPubKeyBuf, ScriptPubKeyTag, ScriptSig, ScriptSigBuf, ScriptSigTag, Tag, TapScript,
+        TapScriptBuf, TapScriptTag, WitnessScript, WitnessScriptBuf, WitnessScriptTag,
+    },
+    transaction::{
+        Ntxid, OutPoint, Transaction, TxIn, TxOut, Txid, Version as TransactionVersion, Wtxid,
+    },
     witness::Witness,
 };
 #[doc(inline)]
 pub use units::{
-    amount::{Amount, Denomination, SignedAmount},
-    block::{BlockHeight, BlockHeightInterval, BlockMtp},
+    amount::{Amount, SignedAmount},
+    block::{BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval},
     fee_rate::FeeRate,
-    time::{self, BlockTime},
+    parse_int,
+    result::{self, NumOpResult},
+    sequence::{self, Sequence},
+    time::{self, BlockTime, BlockTimeDecoder, BlockTimeDecoderError},
     weight::Weight,
 };
 
@@ -205,20 +233,30 @@ pub mod amount {
     use crate::io::{BufRead, Write};
 
     #[rustfmt::skip]            // Keep public re-exports separate.
+    #[cfg(feature = "serde")]
+    pub use units::amount::serde;
     #[doc(inline)]
+    pub use units::amount::{Amount, SignedAmount};
+    #[doc(no_inline)]
     pub use units::amount::{
-        Amount, CheckedSum, Denomination, Display, InvalidCharacterError, MissingDenominationError,
-        MissingDigitsError, OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
-        PossiblyConfusingDenominationError, SignedAmount, TooPreciseError,
-        UnknownDenominationError,
+        Denomination, Display, OutOfRangeError, ParseAmountError, ParseDenominationError,
+        ParseError,
     };
-    #[cfg(feature = "serde")]
-    pub use units::amount::serde;
+
+    /// Error types for bitcoin amounts.
+    pub mod error {
+        pub use units::amount::error::{
+            InputTooLargeError, InvalidCharacterError, MissingDenominationError,
+            MissingDigitsError, OutOfRangeError, ParseAmountError, ParseDenominationError,
+            ParseError, PossiblyConfusingDenominationError, TooPreciseError,
+            UnknownDenominationError,
+        };
+    }
 
     impl Decodable for Amount {
         #[inline]
         fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-            Amount::from_sat(Decodable::consensus_decode(r)?).map_err(|_| {
+            Self::from_sat(Decodable::consensus_decode(r)?).map_err(|_| {
                 consensus::parse_failed_error("amount is greater than Amount::MAX_MONEY")
             })
         }
@@ -232,25 +270,13 @@ pub mod amount {
     }
 }
 
-/// Unit parsing utilities.
-pub mod parse {
-    /// Re-export everything from the [`units::parse`] module.
-    #[doc(inline)]
-    pub use units::parse::{
-        hex_check_unprefixed, hex_remove_prefix, hex_u128, hex_u128_unchecked, hex_u128_unprefixed,
-        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int_from_box, int_from_str,
-        int_from_string, ParseIntError, PrefixedHexError, UnprefixedHexError,
-    };
-}
-
 mod encode_impls {
     //! Encodable/Decodable implementations.
     // While we are deprecating, re-exporting, and generally moving things around just put these here.
 
-    use units::{BlockHeight, BlockHeightInterval};
-
     use crate::consensus::{encode, Decodable, Encodable};
     use crate::io::{BufRead, Write};
+    use crate::{BlockHeight, BlockHeightInterval};
 
     /// Implements Encodable and Decodable for a simple wrapper type.
     ///
diff --git a/bitcoin/src/merkle_tree/block.rs b/bitcoin/src/merkle_tree/block.rs
index fe6589bd36..7b04f6fd6c 100644
--- a/bitcoin/src/merkle_tree/block.rs
+++ b/bitcoin/src/merkle_tree/block.rs
@@ -12,13 +12,14 @@
 use core::convert::Infallible;
 use core::fmt;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 use internals::ToU64 as _;
 use io::{BufRead, Write};
 
-use self::MerkleBlockError::*;
 use crate::block::{self, Block, Checked};
 use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt, MAX_VEC_SIZE};
-use crate::merkle_tree::{MerkleNode as _, TxMerkleNode};
+use crate::merkle_tree::TxMerkleNode;
 use crate::prelude::Vec;
 use crate::transaction::{Transaction, Txid};
 use crate::Weight;
@@ -44,7 +45,6 @@ impl MerkleBlock {
     /// # Examples
     ///
     /// ```rust
-    /// use bitcoin::block::BlockUncheckedExt as _;
     /// use bitcoin::hex::FromHex;
     /// use bitcoin::{Block, MerkleBlock, Txid};
     ///
@@ -97,10 +97,10 @@ impl MerkleBlock {
         let matches: Vec<bool> = block_txids.iter().map(match_txids).collect();
 
         let pmt = PartialMerkleTree::from_txids(block_txids, &matches);
-        MerkleBlock { header: *header, txn: pmt }
+        Self { header: *header, txn: pmt }
     }
 
-    /// Extract the matching txid's represented by this partial Merkle tree
+    /// Extracts the matching txid's represented by this partial Merkle tree
     /// and their respective indices within the partial tree.
     /// returns Ok(()) on success, or error in case of failure
     pub fn extract_matches(
@@ -113,7 +113,7 @@ impl MerkleBlock {
         if merkle_root.eq(&self.header.merkle_root) {
             Ok(())
         } else {
-            Err(MerkleRootMismatch)
+            Err(MerkleBlockError::MerkleRootMismatch)
         }
     }
 }
@@ -127,10 +127,7 @@ impl Encodable for MerkleBlock {
 
 impl Decodable for MerkleBlock {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(MerkleBlock {
-            header: Decodable::consensus_decode(r)?,
-            txn: Decodable::consensus_decode(r)?,
-        })
+        Ok(Self { header: Decodable::consensus_decode(r)?, txn: Decodable::consensus_decode(r)? })
     }
 }
 
@@ -161,11 +158,11 @@ impl Decodable for MerkleBlock {
 ///   N <= 1 + matched_transactions*tree_height
 ///
 /// The serialization format:
-///  - uint32     total_transactions (4 bytes)
-///  - varint     number of hashes   (1-3 bytes)
-///  - uint256[]  hashes in depth-first order (<= 32*N bytes)
-///  - varint     number of bytes of flag bits (1-3 bytes)
-///  - byte[]     flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
+///  - uint32       total_transactions (4 bytes)
+///  - CompactSize  number of hashes   (1-3 bytes)
+///  - uint256[]    hashes in depth-first order (<= 32*N bytes)
+///  - CompactSize  number of bytes of flag bits (1-3 bytes)
+///  - byte[]       flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
 ///
 /// The size constraints follow from this.
 #[derive(PartialEq, Eq, Clone, Debug)]
@@ -199,7 +196,7 @@ impl PartialMerkleTree {
     /// # Examples
     ///
     /// ```rust
-    /// use bitcoin::hash_types::Txid;
+    /// use bitcoin::Txid;
     /// use bitcoin::merkle_tree::PartialMerkleTree;
     ///
     /// // Block 80000
@@ -221,7 +218,7 @@ impl PartialMerkleTree {
         assert_ne!(txids.len(), 0);
         assert_eq!(txids.len(), matches.len());
 
-        let mut pmt = PartialMerkleTree {
+        let mut pmt = Self {
             num_transactions: txids.len() as u32,
             bits: Vec::with_capacity(txids.len()),
             hashes: vec![],
@@ -233,7 +230,7 @@ impl PartialMerkleTree {
         pmt
     }
 
-    /// Extract the matching txid's represented by this partial Merkle tree
+    /// Extracts the matching txid's represented by this partial Merkle tree
     /// and their respective indices within the partial tree.
     /// returns the Merkle root, or error in case of failure
     pub fn extract_matches(
@@ -245,19 +242,19 @@ impl PartialMerkleTree {
         indexes.clear();
         // An empty set will not work
         if self.num_transactions == 0 {
-            return Err(NoTransactions);
+            return Err(MerkleBlockError::NoTransactions);
         };
         // check for excessively high numbers of transactions
         if self.num_transactions.to_u64() > Weight::MAX_BLOCK / Weight::MIN_TRANSACTION {
-            return Err(TooManyTransactions);
+            return Err(MerkleBlockError::TooManyTransactions);
         }
         // there can never be more hashes provided than one for every txid
         if self.hashes.len() as u32 > self.num_transactions {
-            return Err(TooManyHashes);
+            return Err(MerkleBlockError::TooManyHashes);
         };
         // there must be at least one bit per node in the partial tree, and at least one node per hash
         if self.bits.len() < self.hashes.len() {
-            return Err(NotEnoughBits);
+            return Err(MerkleBlockError::NotEnoughBits);
         };
 
         let height = self.calc_tree_height();
@@ -269,12 +266,12 @@ impl PartialMerkleTree {
             self.traverse_and_extract(height, 0, &mut bits_used, &mut hash_used, matches, indexes)?;
         // Verify that all bits were consumed (except for the padding caused by
         // serializing it as a byte sequence)
-        if (bits_used + 7) / 8 != (self.bits.len() as u32 + 7) / 8 {
-            return Err(NotAllBitsConsumed);
+        if bits_used.div_ceil(8) != self.bits.len().div_ceil(8) as u32 {
+            return Err(MerkleBlockError::NotAllBitsConsumed);
         }
         // Verify that all hashes were consumed
         if hash_used != self.hashes.len() as u32 {
-            return Err(NotAllHashesConsumed);
+            return Err(MerkleBlockError::NotAllHashesConsumed);
         }
         Ok(hash_merkle_root)
     }
@@ -295,7 +292,7 @@ impl PartialMerkleTree {
         (self.num_transactions + (1 << height) - 1) >> height
     }
 
-    /// Calculate the hash of a node in the Merkle tree (at leaf level: the txid's themselves)
+    /// Calculates the hash of a node in the Merkle tree (at leaf level: the txid's themselves)
     fn calc_hash(&self, height: u32, pos: u32, txids: &[Txid]) -> TxMerkleNode {
         if height == 0 {
             // Hash at height 0 is the txid itself
@@ -351,14 +348,14 @@ impl PartialMerkleTree {
         indexes: &mut Vec<u32>,
     ) -> Result<TxMerkleNode, MerkleBlockError> {
         if *bits_used as usize >= self.bits.len() {
-            return Err(BitsArrayOverflow);
+            return Err(MerkleBlockError::BitsArrayOverflow);
         }
         let parent_of_match = self.bits[*bits_used as usize];
         *bits_used += 1;
         if height == 0 || !parent_of_match {
             // If at height 0, or nothing interesting below, use stored hash and do not descend
             if *hash_used as usize >= self.hashes.len() {
-                return Err(HashesArrayOverflow);
+                return Err(MerkleBlockError::HashesArrayOverflow);
             }
             let hash = self.hashes[*hash_used as usize];
             *hash_used += 1;
@@ -391,7 +388,7 @@ impl PartialMerkleTree {
                 if right == left {
                     // The left and right branches should never be identical, as the transaction
                     // hashes covered by them must each be unique.
-                    return Err(IdenticalHashesFound);
+                    return Err(MerkleBlockError::IdenticalHashesFound);
                 }
             } else {
                 right = left;
@@ -407,7 +404,7 @@ impl Encodable for PartialMerkleTree {
         let mut ret = self.num_transactions.consensus_encode(w)?;
         ret += self.hashes.consensus_encode(w)?;
 
-        let nb_bytes_for_bits = (self.bits.len() + 7) / 8;
+        let nb_bytes_for_bits = self.bits.len().div_ceil(8);
         ret += w.emit_compact_size(nb_bytes_for_bits)?;
         for chunk in self.bits.chunks(8) {
             let mut byte = 0u8;
@@ -443,7 +440,7 @@ impl Decodable for PartialMerkleTree {
             }
         }
 
-        Ok(PartialMerkleTree { num_transactions, hashes, bits })
+        Ok(Self { num_transactions, hashes, bits })
     }
 }
 
@@ -480,19 +477,17 @@ impl From<Infallible> for MerkleBlockError {
 
 impl fmt::Display for MerkleBlockError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use MerkleBlockError::*;
-
-        match *self {
-            MerkleRootMismatch => write!(f, "Merkle header root doesn't match to the root calculated from the partial Merkle tree"),
-            NoTransactions => write!(f, "partial Merkle tree contains no transactions"),
-            TooManyTransactions => write!(f, "too many transactions"),
-            TooManyHashes => write!(f, "proof contains more hashes than transactions"),
-            NotEnoughBits => write!(f, "proof contains less bits than hashes"),
-            NotAllBitsConsumed => write!(f, "not all bit were consumed"),
-            NotAllHashesConsumed => write!(f, "not all hashes were consumed"),
-            BitsArrayOverflow => write!(f, "overflowed the bits array"),
-            HashesArrayOverflow => write!(f, "overflowed the hashes array"),
-            IdenticalHashesFound => write!(f, "found identical transaction hashes"),
+        match self {
+            Self::MerkleRootMismatch => write!(f, "Merkle header root doesn't match to the root calculated from the partial Merkle tree"),
+            Self::NoTransactions => write!(f, "partial Merkle tree contains no transactions"),
+            Self::TooManyTransactions => write!(f, "too many transactions"),
+            Self::TooManyHashes => write!(f, "proof contains more hashes than transactions"),
+            Self::NotEnoughBits => write!(f, "proof contains fewer bits than hashes"),
+            Self::NotAllBitsConsumed => write!(f, "not all bits were consumed"),
+            Self::NotAllHashesConsumed => write!(f, "not all hashes were consumed"),
+            Self::BitsArrayOverflow => write!(f, "overflowed the bits array"),
+            Self::HashesArrayOverflow => write!(f, "overflowed the hashes array"),
+            Self::IdenticalHashesFound => write!(f, "found identical transaction hashes"),
         }
     }
 }
@@ -500,29 +495,52 @@ impl fmt::Display for MerkleBlockError {
 #[cfg(feature = "std")]
 impl std::error::Error for MerkleBlockError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use MerkleBlockError::*;
-
-        match *self {
-            MerkleRootMismatch | NoTransactions | TooManyTransactions | TooManyHashes
-            | NotEnoughBits | NotAllBitsConsumed | NotAllHashesConsumed | BitsArrayOverflow
-            | HashesArrayOverflow | IdenticalHashesFound => None,
+        match self {
+            Self::MerkleRootMismatch
+            | Self::NoTransactions
+            | Self::TooManyTransactions
+            | Self::TooManyHashes
+            | Self::NotEnoughBits
+            | Self::NotAllBitsConsumed
+            | Self::NotAllHashesConsumed
+            | Self::BitsArrayOverflow
+            | Self::HashesArrayOverflow
+            | Self::IdenticalHashesFound => None,
         }
     }
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for PartialMerkleTree {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            num_transactions: u.arbitrary()?,
+            bits: Vec::<bool>::arbitrary(u)?,
+            hashes: Vec::<TxMerkleNode>::arbitrary(u)?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for MerkleBlock {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { header: u.arbitrary()?, txn: u.arbitrary()? })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use hex::{DisplayHex, FromHex};
     use hex_lit::hex;
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     use {core::cmp, secp256k1::rand::prelude::*};
 
     use super::*;
-    use crate::block::{BlockUncheckedExt as _, Unchecked};
+    use crate::block::Unchecked;
     use crate::consensus::encode;
-    use crate::hash_types::Txid;
+    use crate::Txid;
 
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     macro_rules! pmt_tests {
         ($($name:ident),* $(,)?) => {
             $(
@@ -534,7 +552,7 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     pmt_tests!(
         pmt_test_1,
         pmt_test_4,
@@ -551,12 +569,12 @@ mod tests {
     );
 
     /// Parses the transaction count out of `name` with form: `pmt_test_$num`.
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn pmt_test_from_name(name: &str) { pmt_test(name[9..].parse().unwrap()) }
 
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn pmt_test(tx_count: usize) {
-        let mut rng = thread_rng();
+        let mut rng = secp256k1::rand::rng();
         // Create some fake tx ids
         let tx_ids = (1..=tx_count)
             .map(|i| format!("{:064x}", i).parse::<Txid>().unwrap())
@@ -568,7 +586,7 @@ mod tests {
         let mut height = 1;
         let mut ntx = tx_count;
         while ntx > 1 {
-            ntx = (ntx + 1) / 2;
+            ntx = ntx.div_ceil(2);
             height += 1;
         }
 
@@ -580,7 +598,7 @@ mod tests {
                 // Generate `att / 2` random bits
                 let rand_bits = match att / 2 {
                     0 => 0,
-                    bits => rng.gen::<u64>() >> (64 - bits),
+                    bits => rng.random::<u64>() >> (64 - bits),
                 };
                 let include = rand_bits == 0;
                 matches[j] = include;
@@ -596,7 +614,7 @@ mod tests {
 
             // Verify PartialMerkleTree's size guarantees
             let n = cmp::min(tx_count, 1 + match_txid1.len() * height);
-            assert!(serialized.len() <= 10 + (258 * n + 7) / 8);
+            assert!(serialized.len() <= 10 + (258 * n).div_ceil(8));
 
             // Deserialize into a tester copy
             let pmt2: PartialMerkleTree =
@@ -661,7 +679,7 @@ mod tests {
         assert_eq!(mb_hex, encode::serialize(&mb).to_lower_hex_string().as_str());
     }
 
-    /// Constructs a new CMerkleBlock using a list of txids which will be found in the
+    /// Constructs a new MerkleBlock using a list of txids which will be found in the
     /// given block.
     #[test]
     fn merkleblock_construct_from_txids_found() {
@@ -681,7 +699,7 @@ mod tests {
 
         let merkle_block = MerkleBlock::from_block_with_predicate(&block, |t| txids.contains(t));
 
-        assert_eq!(merkle_block.header.block_hash(), block.clone().block_hash());
+        assert_eq!(merkle_block.header.block_hash(), block.block_hash());
 
         let mut matches: Vec<Txid> = vec![];
         let mut index: Vec<u32> = vec![];
@@ -700,7 +718,7 @@ mod tests {
         assert_eq!(index[1], 8);
     }
 
-    /// Constructs a new CMerkleBlock using a list of txids which will not be found in the given block
+    /// Constructs a new MerkleBlock using a list of txids which will not be found in the given block
     #[test]
     fn merkleblock_construct_from_txids_not_found() {
         let block = get_block_13b8a();
@@ -711,7 +729,7 @@ mod tests {
 
         let merkle_block = MerkleBlock::from_block_with_predicate(&block, |t| txids.contains(t));
 
-        assert_eq!(merkle_block.header.block_hash(), block.clone().block_hash());
+        assert_eq!(merkle_block.header.block_hash(), block.block_hash());
 
         let mut matches: Vec<Txid> = vec![];
         let mut index: Vec<u32> = vec![];
@@ -724,12 +742,12 @@ mod tests {
         assert_eq!(index.len(), 0);
     }
 
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     impl PartialMerkleTree {
         /// Flip one bit in one of the hashes - this should break the authentication
         fn damage(&mut self, rng: &mut ThreadRng) {
-            let n = rng.gen_range(0..self.hashes.len());
-            let bit = rng.gen::<u8>();
+            let n = rng.random_range(0..self.hashes.len());
+            let bit = rng.random::<u8>();
             let hashes = &mut self.hashes;
             let mut hash = hashes[n].to_byte_array();
             hash[(bit >> 3) as usize] ^= 1 << (bit & 7);
diff --git a/bitcoin/src/merkle_tree/mod.rs b/bitcoin/src/merkle_tree/mod.rs
index 82801fdd43..8199594912 100644
--- a/bitcoin/src/merkle_tree/mod.rs
+++ b/bitcoin/src/merkle_tree/mod.rs
@@ -6,7 +6,7 @@
 //!
 //! ```
 //! # use bitcoin::Txid;
-//! # use bitcoin::merkle_tree::{MerkleNode as _, TxMerkleNode};
+//! # use bitcoin::merkle_tree::TxMerkleNode;
 //! # let tx1 = Txid::from_byte_array([0xAA; 32]);  // Arbitrary dummy hash values.
 //! # let tx2 = Txid::from_byte_array([0xFF; 32]);
 //! let tx_hashes = [tx1, tx2]; // All the hashes we wish to merkelize.
@@ -16,100 +16,35 @@
 
 mod block;
 
-use hashes::{sha256d, HashEngine as _};
-
-use crate::internal_macros::impl_hashencode;
-use crate::prelude::Vec;
-use crate::transaction::TxIdentifier;
-use crate::{Txid, Wtxid};
+use io::{BufRead, Write};
 
 #[rustfmt::skip]
 #[doc(inline)]
 pub use self::block::{MerkleBlock, MerkleBlockError, PartialMerkleTree};
-pub use primitives::merkle_tree::{TxMerkleNode, WitnessMerkleNode};
-
-impl_hashencode!(TxMerkleNode);
-impl_hashencode!(WitnessMerkleNode);
-
-/// A node in a Merkle tree of transactions or witness data within a block.
-///
-/// This trait is used to compute the transaction Merkle root contained in
-/// a block header. This is a particularly weird algorithm -- it interprets
-/// the list of transactions as a balanced binary tree, duplicating branches
-/// as needed to fill out the tree to a power of two size.
-///
-/// Other Merkle trees in Bitcoin, such as those used in Taproot commitments,
-/// do not use this algorithm and cannot use this trait.
-pub trait MerkleNode: Copy {
-    /// The hash (TXID or WTXID) of a transaction in the tree.
-    type Leaf: TxIdentifier;
-
-    /// Convert a hash to a leaf node of the tree.
-    fn from_leaf(leaf: Self::Leaf) -> Self;
-    /// Combine two nodes to get a single node. The final node of a tree is called the "root".
-    fn combine(&self, other: &Self) -> Self;
+pub use primitives::{TxMerkleNode, WitnessMerkleNode};
 
-    /// Given an iterator of leaves, compute the Merkle root.
-    ///
-    /// Returns `None` iff the iterator was empty.
-    fn calculate_root<I: Iterator<Item = Self::Leaf>>(iter: I) -> Option<Self> {
-        let mut stack = Vec::<(usize, Self)>::with_capacity(32);
-        // Start with a standard Merkle tree root computation...
-        for (mut n, leaf) in iter.enumerate() {
-            stack.push((0, Self::from_leaf(leaf)));
+use crate::consensus::{encode, Decodable, Encodable};
 
-            while n & 1 == 1 {
-                let right = stack.pop().unwrap();
-                let left = stack.pop().unwrap();
-                debug_assert_eq!(left.0, right.0);
-                stack.push((left.0 + 1, left.1.combine(&right.1)));
-                n >>= 1;
-            }
-        }
-        // ...then, deal with incomplete trees. Bitcoin does a weird thing in
-        // which it doubles-up nodes of the tree to fill out the tree, rather
-        // than treating incomplete branches specially. This, along with its
-        // conflation of leaves with leaf hashes, makes its Merkle tree
-        // construction theoretically (though probably not practically)
-        // vulnerable to collisions. This is consensus logic so we just have
-        // to accept it.
-        while stack.len() > 1 {
-            let mut right = stack.pop().unwrap();
-            let left = stack.pop().unwrap();
-            while right.0 != left.0 {
-                assert!(right.0 < left.0);
-                right = (right.0 + 1, right.1.combine(&right.1)); // combine with self
-            }
-            stack.push((left.0 + 1, left.1.combine(&right.1)));
-        }
-
-        stack.pop().map(|(_, h)| h)
+impl Encodable for TxMerkleNode {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_byte_array().consensus_encode(w)
     }
 }
 
-// These two impl blocks are identical. FIXME once we have nailed down
-// our hash traits, it should be possible to put bounds on `MerkleNode`
-// and `MerkleNode::Leaf` which are sufficient to turn both methods into
-// provided methods in the trait definition.
-impl MerkleNode for TxMerkleNode {
-    type Leaf = Txid;
-    fn from_leaf(leaf: Self::Leaf) -> Self { Self::from_byte_array(leaf.to_byte_array()) }
+impl Decodable for TxMerkleNode {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(r)?))
+    }
+}
 
-    fn combine(&self, other: &Self) -> Self {
-        let mut encoder = sha256d::Hash::engine();
-        encoder.input(self.as_byte_array());
-        encoder.input(other.as_byte_array());
-        Self::from_byte_array(sha256d::Hash::from_engine(encoder).to_byte_array())
+impl Encodable for WitnessMerkleNode {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_byte_array().consensus_encode(w)
     }
 }
-impl MerkleNode for WitnessMerkleNode {
-    type Leaf = Wtxid;
-    fn from_leaf(leaf: Self::Leaf) -> Self { Self::from_byte_array(leaf.to_byte_array()) }
 
-    fn combine(&self, other: &Self) -> Self {
-        let mut encoder = sha256d::Hash::engine();
-        encoder.input(self.as_byte_array());
-        encoder.input(other.as_byte_array());
-        Self::from_byte_array(sha256d::Hash::from_engine(encoder).to_byte_array())
+impl Decodable for WitnessMerkleNode {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(r)?))
     }
 }
diff --git a/bitcoin/src/network/mod.rs b/bitcoin/src/network/mod.rs
index 6137afda97..3de1b280c9 100644
--- a/bitcoin/src/network/mod.rs
+++ b/bitcoin/src/network/mod.rs
@@ -5,18 +5,6 @@
 //! The term "network" is overloaded, here [`Network`] refers to the specific
 //! Bitcoin network we are operating on e.g., signet, regtest. The terms
 //! "network" and "chain" are often used interchangeably for this concept.
-//!
-//! # Example: encoding a network's magic bytes
-//!
-//! ```rust
-//! use bitcoin::Network;
-//! use bitcoin::consensus::encode::serialize;
-//!
-//! let network = Network::Bitcoin;
-//! let bytes = serialize(&network.magic());
-//!
-//! assert_eq!(&bytes[..], &[0xF9, 0xBE, 0xB4, 0xD9]);
-//! ```
 
 pub mod params;
 
@@ -28,7 +16,6 @@ use internals::write_err;
 use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::constants::ChainHash;
-use crate::p2p::Magic;
 use crate::prelude::{String, ToOwned};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -48,7 +35,7 @@ pub enum NetworkKind {
 // ambiguous due to confusion caused by signet/testnet/regtest.
 impl NetworkKind {
     /// Returns true if this is real mainnet bitcoin.
-    pub fn is_mainnet(&self) -> bool { *self == NetworkKind::Main }
+    pub fn is_mainnet(&self) -> bool { *self == Self::Main }
 }
 
 impl From<Network> for NetworkKind {
@@ -56,8 +43,8 @@ impl From<Network> for NetworkKind {
         use Network::*;
 
         match n {
-            Bitcoin => NetworkKind::Main,
-            Testnet(_) | Signet | Regtest => NetworkKind::Test,
+            Bitcoin => Self::Main,
+            Testnet(_) | Signet | Regtest => Self::Test,
         }
     }
 }
@@ -73,8 +60,16 @@ pub enum TestnetVersion {
 }
 
 /// The cryptocurrency network to act on.
+///
+/// This is an exhaustive enum, meaning that we cannot add any future networks without defining a
+/// new, incompatible version of this type. If you are using this type directly and wish to support the
+/// new network, this will be a breaking change to your APIs and likely require changes in your code.
+///
+/// If you are concerned about forward compatibility, consider using `T: Into<Params>` instead of
+/// this type as a parameter to functions in your public API, or directly using the `Params` type.
+// For extensive discussion on the usage of `non_exhaustive` please see:
+// https://github.com/rust-bitcoin/rust-bitcoin/issues/2225
 #[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Hash, Debug)]
-#[non_exhaustive]
 pub enum Network {
     /// Mainnet Bitcoin.
     Bitcoin,
@@ -124,33 +119,6 @@ impl<'de> Deserialize<'de> for Network {
 }
 
 impl Network {
-    /// Constructs a new `Network` from the magic bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin::p2p::Magic;
-    /// use bitcoin::Network;
-    ///
-    /// assert_eq!(Ok(Network::Bitcoin), Network::try_from(Magic::from_bytes([0xF9, 0xBE, 0xB4, 0xD9])));
-    /// assert_eq!(None, Network::from_magic(Magic::from_bytes([0xFF, 0xFF, 0xFF, 0xFF])));
-    /// ```
-    pub fn from_magic(magic: Magic) -> Option<Network> { Network::try_from(magic).ok() }
-
-    /// Return the network magic bytes, which should be encoded little-endian
-    /// at the start of every message
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin::p2p::Magic;
-    /// use bitcoin::Network;
-    ///
-    /// let network = Network::Bitcoin;
-    /// assert_eq!(network.magic(), Magic::from_bytes([0xF9, 0xBE, 0xB4, 0xD9]));
-    /// ```
-    pub fn magic(self) -> Magic { Magic::from(self) }
-
     /// Converts a `Network` to its equivalent `bitcoind -chain` argument name.
     ///
     /// ```bash
@@ -162,12 +130,12 @@ impl Network {
     /// ```
     pub fn to_core_arg(self) -> &'static str {
         match self {
-            Network::Bitcoin => "main",
+            Self::Bitcoin => "main",
             // For user-side compatibility, testnet3 is retained as test
-            Network::Testnet(TestnetVersion::V3) => "test",
-            Network::Testnet(TestnetVersion::V4) => "testnet4",
-            Network::Signet => "signet",
-            Network::Regtest => "regtest",
+            Self::Testnet(TestnetVersion::V3) => "test",
+            Self::Testnet(TestnetVersion::V4) => "testnet4",
+            Self::Signet => "signet",
+            Self::Regtest => "regtest",
         }
     }
 
@@ -217,18 +185,18 @@ impl Network {
     ///
     /// assert_eq!(Ok(Network::Bitcoin), Network::try_from(ChainHash::BITCOIN));
     /// ```
-    pub fn from_chain_hash(chain_hash: ChainHash) -> Option<Network> {
-        Network::try_from(chain_hash).ok()
+    pub fn from_chain_hash(chain_hash: ChainHash) -> Option<Self> {
+        Self::try_from(chain_hash).ok()
     }
 
     /// Returns the associated network parameters.
     pub const fn params(self) -> &'static Params {
         match self {
-            Network::Bitcoin => &Params::BITCOIN,
-            Network::Testnet(TestnetVersion::V3) => &Params::TESTNET3,
-            Network::Testnet(TestnetVersion::V4) => &Params::TESTNET4,
-            Network::Signet => &Params::SIGNET,
-            Network::Regtest => &Params::REGTEST,
+            Self::Bitcoin => &Params::BITCOIN,
+            Self::Testnet(TestnetVersion::V3) => &Params::TESTNET3,
+            Self::Testnet(TestnetVersion::V4) => &Params::TESTNET4,
+            Self::Signet => &Params::SIGNET,
+            Self::Regtest => &Params::REGTEST,
         }
     }
 
@@ -236,11 +204,11 @@ impl Network {
     /// This is useful for displaying the network type as a string.
     const fn as_display_str(self) -> &'static str {
         match self {
-            Network::Bitcoin => "bitcoin",
-            Network::Testnet(TestnetVersion::V3) => "testnet",
-            Network::Testnet(TestnetVersion::V4) => "testnet4",
-            Network::Signet => "signet",
-            Network::Regtest => "regtest",
+            Self::Bitcoin => "bitcoin",
+            Self::Testnet(TestnetVersion::V3) => "testnet",
+            Self::Testnet(TestnetVersion::V4) => "testnet4",
+            Self::Signet => "signet",
+            Self::Regtest => "regtest",
         }
     }
 }
@@ -311,12 +279,12 @@ impl FromStr for Network {
     #[inline]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "bitcoin" => Ok(Network::Bitcoin),
+            "bitcoin" => Ok(Self::Bitcoin),
             // For user-side compatibility, testnet3 is retained as testnet
-            "testnet" => Ok(Network::Testnet(TestnetVersion::V3)),
-            "testnet4" => Ok(Network::Testnet(TestnetVersion::V4)),
-            "signet" => Ok(Network::Signet),
-            "regtest" => Ok(Network::Regtest),
+            "testnet" => Ok(Self::Testnet(TestnetVersion::V3)),
+            "testnet4" => Ok(Self::Testnet(TestnetVersion::V4)),
+            "signet" => Ok(Self::Signet),
+            "regtest" => Ok(Self::Regtest),
             _ => Err(ParseNetworkError(s.to_owned())),
         }
     }
@@ -350,11 +318,11 @@ impl TryFrom<ChainHash> for Network {
     fn try_from(chain_hash: ChainHash) -> Result<Self, Self::Error> {
         match chain_hash {
             // Note: any new network entries must be matched against here.
-            ChainHash::BITCOIN => Ok(Network::Bitcoin),
-            ChainHash::TESTNET3 => Ok(Network::Testnet(TestnetVersion::V3)),
-            ChainHash::TESTNET4 => Ok(Network::Testnet(TestnetVersion::V4)),
-            ChainHash::SIGNET => Ok(Network::Signet),
-            ChainHash::REGTEST => Ok(Network::Regtest),
+            ChainHash::BITCOIN => Ok(Self::Bitcoin),
+            ChainHash::TESTNET3 => Ok(Self::Testnet(TestnetVersion::V3)),
+            ChainHash::TESTNET4 => Ok(Self::Testnet(TestnetVersion::V4)),
+            ChainHash::SIGNET => Ok(Self::Signet),
+            ChainHash::REGTEST => Ok(Self::Regtest),
             _ => Err(UnknownChainHashError(chain_hash)),
         }
     }
@@ -363,35 +331,6 @@ impl TryFrom<ChainHash> for Network {
 #[cfg(test)]
 mod tests {
     use super::{Network, TestnetVersion};
-    use crate::consensus::encode::{deserialize, serialize};
-    use crate::p2p::ServiceFlags;
-
-    #[test]
-    fn serialize_deserialize() {
-        assert_eq!(serialize(&Network::Bitcoin.magic()), &[0xf9, 0xbe, 0xb4, 0xd9]);
-        assert_eq!(
-            serialize(&Network::Testnet(TestnetVersion::V3).magic()),
-            &[0x0b, 0x11, 0x09, 0x07]
-        );
-        assert_eq!(
-            serialize(&Network::Testnet(TestnetVersion::V4).magic()),
-            &[0x1c, 0x16, 0x3f, 0x28]
-        );
-        assert_eq!(serialize(&Network::Signet.magic()), &[0x0a, 0x03, 0xcf, 0x40]);
-        assert_eq!(serialize(&Network::Regtest.magic()), &[0xfa, 0xbf, 0xb5, 0xda]);
-
-        assert_eq!(deserialize(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(), Some(Network::Bitcoin.magic()));
-        assert_eq!(
-            deserialize(&[0x0b, 0x11, 0x09, 0x07]).ok(),
-            Some(Network::Testnet(TestnetVersion::V3).magic())
-        );
-        assert_eq!(
-            deserialize(&[0x1c, 0x16, 0x3f, 0x28]).ok(),
-            Some(Network::Testnet(TestnetVersion::V4).magic())
-        );
-        assert_eq!(deserialize(&[0x0a, 0x03, 0xcf, 0x40]).ok(), Some(Network::Signet.magic()));
-        assert_eq!(deserialize(&[0xfa, 0xbf, 0xb5, 0xda]).ok(), Some(Network::Regtest.magic()));
-    }
 
     #[test]
     fn string() {
@@ -409,47 +348,6 @@ mod tests {
         assert!("fakenet".parse::<Network>().is_err());
     }
 
-    #[test]
-    fn service_flags() {
-        let all = [
-            ServiceFlags::NETWORK,
-            ServiceFlags::GETUTXO,
-            ServiceFlags::BLOOM,
-            ServiceFlags::WITNESS,
-            ServiceFlags::COMPACT_FILTERS,
-            ServiceFlags::NETWORK_LIMITED,
-            ServiceFlags::P2P_V2,
-        ];
-
-        let mut flags = ServiceFlags::NONE;
-        for f in all.iter() {
-            assert!(!flags.has(*f));
-        }
-
-        flags |= ServiceFlags::WITNESS;
-        assert_eq!(flags, ServiceFlags::WITNESS);
-
-        let mut flags2 = flags | ServiceFlags::GETUTXO;
-        for f in all.iter() {
-            assert_eq!(flags2.has(*f), *f == ServiceFlags::WITNESS || *f == ServiceFlags::GETUTXO);
-        }
-
-        flags2 ^= ServiceFlags::WITNESS;
-        assert_eq!(flags2, ServiceFlags::GETUTXO);
-
-        flags2 |= ServiceFlags::COMPACT_FILTERS;
-        flags2 ^= ServiceFlags::GETUTXO;
-        assert_eq!(flags2, ServiceFlags::COMPACT_FILTERS);
-
-        // Test formatting.
-        assert_eq!("ServiceFlags(NONE)", ServiceFlags::NONE.to_string());
-        assert_eq!("ServiceFlags(WITNESS)", ServiceFlags::WITNESS.to_string());
-        let flag = ServiceFlags::WITNESS | ServiceFlags::BLOOM | ServiceFlags::NETWORK;
-        assert_eq!("ServiceFlags(NETWORK|BLOOM|WITNESS)", flag.to_string());
-        let flag = ServiceFlags::WITNESS | 0xf0.into();
-        assert_eq!("ServiceFlags(WITNESS|COMPACT_FILTERS|0xb0)", flag.to_string());
-    }
-
     #[test]
     #[cfg(feature = "serde")]
     fn serde_roundtrip() {
diff --git a/bitcoin/src/network/params.rs b/bitcoin/src/network/params.rs
index 493354e69c..7fd79a0006 100644
--- a/bitcoin/src/network/params.rs
+++ b/bitcoin/src/network/params.rs
@@ -12,15 +12,13 @@
 //!
 //! ```
 //! use bitcoin::network::Params;
-//! use bitcoin::{p2p, Script, ScriptBuf, Network, Target};
+//! use bitcoin::{WitnessScript, WitnessScriptBuf, Network, Target};
 //!
 //! const POW_TARGET_SPACING: u64 = 120; // Two minutes.
-//! const MAGIC: [u8; 4] = [1, 2, 3, 4];
 //!
 //! pub struct CustomParams {
 //!     params: Params,
-//!     magic: [u8; 4],
-//!     challenge_script: ScriptBuf,
+//!     challenge_script: WitnessScriptBuf,
 //! }
 //!
 //! impl CustomParams {
@@ -29,21 +27,17 @@
 //!         let mut params = Params::new(Network::Signet);
 //!         params.pow_target_spacing = POW_TARGET_SPACING;
 //!
-//!         // This would be something real (see BIP-325).
-//!         let challenge_script = ScriptBuf::new();
+//!         // This would be something real (see BIP-00325).
+//!         let challenge_script = WitnessScriptBuf::new();
 //!
 //!         Self {
 //!             params,
-//!             magic: MAGIC,
 //!             challenge_script,
 //!         }
 //!     }
 //!
-//!     /// Returns the custom magic bytes.
-//!     pub fn magic(&self) -> p2p::Magic { p2p::Magic::from_bytes(self.magic) }
-//!
 //!     /// Returns the custom signet challenge script.
-//!     pub fn challenge_script(&self) -> &Script { &self.challenge_script }
+//!     pub fn challenge_script(&self) -> &WitnessScript { &self.challenge_script }
 //! }
 //!
 //! impl AsRef<Params> for CustomParams {
@@ -61,19 +55,16 @@
 //! #    let _ = target.difficulty(signet);
 //! #
 //! #    let custom = CustomParams::new();
-//! #    let _ = custom.magic();
 //! #    let _ = custom.challenge_script();
 //! #    let _ = target.difficulty(custom);
 //! # }
 //! ```
 
-use units::{BlockHeight, BlockHeightInterval};
-
-use crate::network::Network;
+use super::{Network, TestnetVersion};
 #[cfg(doc)]
 use crate::pow::CompactTarget;
 use crate::pow::Target;
-use crate::TestnetVersion;
+use crate::{BlockHeight, BlockHeightInterval};
 
 /// Parameters that influence chain consensus.
 #[non_exhaustive]
@@ -81,16 +72,16 @@ use crate::TestnetVersion;
 pub struct Params {
     /// Network for which parameters are valid.
     pub network: Network,
-    /// Time when BIP16 becomes active.
+    /// Time when BIP-0016 becomes active.
     pub bip16_time: u32,
-    /// Block height at which BIP34 becomes active.
+    /// Block height at which BIP-0034 becomes active.
     pub bip34_height: BlockHeight,
-    /// Block height at which BIP65 becomes active.
+    /// Block height at which BIP-0065 becomes active.
     pub bip65_height: BlockHeight,
-    /// Block height at which BIP66 becomes active.
+    /// Block height at which BIP-0066 becomes active.
     pub bip66_height: BlockHeight,
     /// Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,
-    /// (nPowTargetTimespan / nPowTargetSpacing) which is also used for BIP9 deployments.
+    /// (nPowTargetTimespan / nPowTargetSpacing) which is also used for BIP-0009 deployments.
     /// Examples: 1916 for 95%, 1512 for testchains.
     pub rule_change_activation_threshold: BlockHeightInterval,
     /// Number of blocks with the same set of rules.
@@ -129,7 +120,7 @@ pub struct Params {
 /// [using-statics-or-consts]: <https://doc.rust-lang.org/reference/items/static-items.html#using-statics-or-consts>
 pub static MAINNET: Params = Params::MAINNET;
 /// The testnet3 parameters.
-#[deprecated(since = "0.33.0", note = "use `TESTNET3` instead")]
+#[deprecated(since = "TBD", note = "use `TESTNET3` instead")]
 pub static TESTNET: Params = Params::TESTNET3;
 /// The testnet3 parameters.
 pub static TESTNET3: Params = Params::TESTNET3;
@@ -143,10 +134,10 @@ pub static REGTEST: Params = Params::REGTEST;
 #[allow(deprecated)] // For `pow_limit`.
 impl Params {
     /// The mainnet parameters (alias for `Params::MAINNET`).
-    pub const BITCOIN: Params = Params::MAINNET;
+    pub const BITCOIN: Self = Self::MAINNET;
 
     /// The mainnet parameters.
-    pub const MAINNET: Params = Params {
+    pub const MAINNET: Self = Self {
         network: Network::Bitcoin,
         bip16_time: 1333238400,                      // Apr 1 2012
         bip34_height: BlockHeight::from_u32(227931), // 000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8
@@ -163,8 +154,8 @@ impl Params {
     };
 
     /// The testnet3 parameters.
-    #[deprecated(since = "0.33.0", note = "use `TESTNET3` instead")]
-    pub const TESTNET: Params = Params {
+    #[deprecated(since = "TBD", note = "use `TESTNET3` instead")]
+    pub const TESTNET: Self = Self {
         network: Network::Testnet(TestnetVersion::V3),
         bip16_time: 1333238400,                      // Apr 1 2012
         bip34_height: BlockHeight::from_u32(21111), // 0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8
@@ -181,7 +172,7 @@ impl Params {
     };
 
     /// The testnet3 parameters.
-    pub const TESTNET3: Params = Params {
+    pub const TESTNET3: Self = Self {
         network: Network::Testnet(TestnetVersion::V3),
         bip16_time: 1333238400,                      // Apr 1 2012
         bip34_height: BlockHeight::from_u32(21111), // 0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8
@@ -198,7 +189,7 @@ impl Params {
     };
 
     /// The testnet4 parameters.
-    pub const TESTNET4: Params = Params {
+    pub const TESTNET4: Self = Self {
         network: Network::Testnet(TestnetVersion::V4),
         bip16_time: 1333238400, // Apr 1 2012
         bip34_height: BlockHeight::from_u32(1),
@@ -215,7 +206,7 @@ impl Params {
     };
 
     /// The signet parameters.
-    pub const SIGNET: Params = Params {
+    pub const SIGNET: Self = Self {
         network: Network::Signet,
         bip16_time: 1333238400, // Apr 1 2012
         bip34_height: BlockHeight::from_u32(1),
@@ -232,7 +223,7 @@ impl Params {
     };
 
     /// The regtest parameters.
-    pub const REGTEST: Params = Params {
+    pub const REGTEST: Self = Self {
         network: Network::Regtest,
         bip16_time: 1333238400,                         // Apr 1 2012
         bip34_height: BlockHeight::from_u32(100000000), // not activated on regtest
@@ -248,14 +239,14 @@ impl Params {
         no_pow_retargeting: true,
     };
 
-    /// Creates parameters set for the given network.
+    /// Constructs parameters set for the given network.
     pub const fn new(network: Network) -> Self {
         match network {
-            Network::Bitcoin => Params::MAINNET,
-            Network::Testnet(TestnetVersion::V3) => Params::TESTNET3,
-            Network::Testnet(TestnetVersion::V4) => Params::TESTNET4,
-            Network::Signet => Params::SIGNET,
-            Network::Regtest => Params::REGTEST,
+            Network::Bitcoin => Self::MAINNET,
+            Network::Testnet(TestnetVersion::V3) => Self::TESTNET3,
+            Network::Testnet(TestnetVersion::V4) => Self::TESTNET4,
+            Network::Signet => Self::SIGNET,
+            Network::Regtest => Self::REGTEST,
         }
     }
 
@@ -281,8 +272,8 @@ impl From<&Network> for &'static Params {
     fn from(value: &Network) -> Self { value.params() }
 }
 
-impl AsRef<Params> for Params {
-    fn as_ref(&self) -> &Params { self }
+impl AsRef<Self> for Params {
+    fn as_ref(&self) -> &Self { self }
 }
 
 impl AsRef<Params> for Network {
diff --git a/bitcoin/src/p2p/address.rs b/bitcoin/src/p2p/address.rs
deleted file mode 100644
index 576b257b2f..0000000000
--- a/bitcoin/src/p2p/address.rs
+++ /dev/null
@@ -1,690 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin network addresses.
-//!
-//! This module defines the structures and functions needed to encode
-//! network addresses in Bitcoin messages.
-
-use core::{fmt, iter};
-use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
-
-use io::{BufRead, Read, Write};
-
-use crate::consensus;
-use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
-use crate::p2p::ServiceFlags;
-
-/// A message which can be sent on the Bitcoin network
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct Address {
-    /// Services provided by the peer whose address this is
-    pub services: ServiceFlags,
-    /// Network byte-order ipv6 address, or ipv4-mapped ipv6 address
-    pub address: [u16; 8],
-    /// Network port
-    pub port: u16,
-}
-
-const ONION: [u16; 3] = [0xFD87, 0xD87E, 0xEB43];
-
-impl Address {
-    /// Construct a new address message for a socket
-    pub fn new(socket: &SocketAddr, services: ServiceFlags) -> Address {
-        let (address, port) = match *socket {
-            SocketAddr::V4(addr) => (addr.ip().to_ipv6_mapped().segments(), addr.port()),
-            SocketAddr::V6(addr) => (addr.ip().segments(), addr.port()),
-        };
-        Address { address, port, services }
-    }
-
-    /// Extract socket address from an [Address] message.
-    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
-    /// if the message contains a Tor address.
-    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
-        let addr = &self.address;
-        if addr[0..3] == ONION {
-            return Err(io::Error::from(io::ErrorKind::AddrNotAvailable));
-        }
-        let ipv6 =
-            Ipv6Addr::new(addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
-        if let Some(ipv4) = ipv6.to_ipv4() {
-            Ok(SocketAddr::V4(SocketAddrV4::new(ipv4, self.port)))
-        } else {
-            Ok(SocketAddr::V6(SocketAddrV6::new(ipv6, self.port, 0, 0)))
-        }
-    }
-}
-
-impl Encodable for Address {
-    #[inline]
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        let mut len = self.services.consensus_encode(w)?;
-
-        for word in &self.address {
-            w.write_all(&word.to_be_bytes())?;
-            len += 2;
-        }
-
-        w.write_all(&self.port.to_be_bytes())?;
-        len += 2;
-
-        Ok(len)
-    }
-}
-
-impl Decodable for Address {
-    #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(Address {
-            services: Decodable::consensus_decode(r)?,
-            address: read_be_address(r)?,
-            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
-        })
-    }
-}
-
-/// Read a big-endian address from reader.
-fn read_be_address<R: Read + ?Sized>(r: &mut R) -> Result<[u16; 8], encode::Error> {
-    let mut address = [0u16; 8];
-    let mut buf = [0u8; 2];
-
-    for word in &mut address {
-        Read::read_exact(r, &mut buf)?;
-        *word = u16::from_be_bytes(buf)
-    }
-    Ok(address)
-}
-
-impl fmt::Debug for Address {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let ipv6 = Ipv6Addr::from(self.address);
-
-        match ipv6.to_ipv4() {
-            Some(addr) => write!(
-                f,
-                "Address {{services: {}, address: {}, port: {}}}",
-                self.services, addr, self.port
-            ),
-            None => write!(
-                f,
-                "Address {{services: {}, address: {}, port: {}}}",
-                self.services, ipv6, self.port
-            ),
-        }
-    }
-}
-
-impl ToSocketAddrs for Address {
-    type Iter = iter::Once<SocketAddr>;
-    fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
-        Ok(iter::once(self.socket_addr()?))
-    }
-}
-
-/// Supported networks for use in BIP155 addrv2 message
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub enum AddrV2 {
-    /// IPV4
-    Ipv4(Ipv4Addr),
-    /// IPV6
-    Ipv6(Ipv6Addr),
-    /// TORV3
-    TorV3([u8; 32]),
-    /// I2P
-    I2p([u8; 32]),
-    /// CJDNS
-    Cjdns(Ipv6Addr),
-    /// Unknown
-    Unknown(u8, Vec<u8>),
-}
-
-/// Error types for [`AddrV2`] to [`SocketAddr`] conversion.
-#[derive(Debug, PartialEq, Eq)]
-pub enum AddrV2ConversionError {
-    /// A [`AddrV2::TorV3`] address cannot be converted to a [`SocketAddr`].
-    TorV3NotSupported,
-    /// A [`AddrV2::I2p`] address cannot be converted to a [`SocketAddr`].
-    I2pNotSupported,
-    /// A [`AddrV2::Cjdns`] address can be converted to a [`SocketAddr`],
-    /// but it won't work with a tradicional socket API.
-    CjdnsNotRecommended,
-    /// A [`AddrV2::Unknown`] address cannot be converted to a [`SocketAddr`].
-    UnknownNotSupported,
-}
-
-impl fmt::Display for AddrV2ConversionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::TorV3NotSupported => write!(f, "TorV3 addresses cannot be converted to SocketAddr"),
-            Self::I2pNotSupported => write!(f, "I2P addresses cannot be converted to SocketAddr"),
-            Self::CjdnsNotRecommended => write!(f, "CJDNS addresses can be converted to SocketAddr, but won't work with a traditional socket API"),
-            Self::UnknownNotSupported => write!(f, "Unknown address type cannot be converted to SocketAddr"),
-        }
-    }
-}
-
-impl std::error::Error for AddrV2ConversionError {}
-
-impl From<SocketAddr> for AddrV2 {
-    fn from(addr: SocketAddr) -> Self {
-        match addr {
-            SocketAddr::V4(sock) => AddrV2::Ipv4(*sock.ip()),
-            SocketAddr::V6(sock) => {
-                // CJDNS uses the IPv6 network `fc00::/8`
-                // All CJDNS addresses must have `0xfc00` as the first and second octets
-                let ip = *sock.ip();
-                if ip.octets()[0] == 0xfc && ip.octets()[1] == 0x00 {
-                    AddrV2::Cjdns(ip)
-                } else {
-                    AddrV2::Ipv6(ip)
-                }
-            }
-        }
-    }
-}
-
-impl TryFrom<AddrV2> for SocketAddr {
-    type Error = AddrV2ConversionError;
-
-    fn try_from(addr: AddrV2) -> Result<SocketAddr, Self::Error> {
-        match addr {
-            AddrV2::Ipv4(ip) => Ok(SocketAddr::V4(SocketAddrV4::new(ip, 0))),
-            AddrV2::Ipv6(ip) => Ok(SocketAddr::V6(SocketAddrV6::new(ip, 0, 0, 0))),
-            AddrV2::Cjdns(_) => Err(AddrV2ConversionError::CjdnsNotRecommended),
-            AddrV2::TorV3(_) => Err(AddrV2ConversionError::TorV3NotSupported),
-            AddrV2::I2p(_) => Err(AddrV2ConversionError::I2pNotSupported),
-            AddrV2::Unknown(_, _) => Err(AddrV2ConversionError::UnknownNotSupported),
-        }
-    }
-}
-
-impl Encodable for AddrV2 {
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        fn encode_addr<W: Write + ?Sized>(
-            w: &mut W,
-            network: u8,
-            bytes: &[u8],
-        ) -> Result<usize, io::Error> {
-            Ok(network.consensus_encode(w)? + encode::consensus_encode_with_size(bytes, w)?)
-        }
-        Ok(match *self {
-            AddrV2::Ipv4(ref addr) => encode_addr(w, 1, &addr.octets())?,
-            AddrV2::Ipv6(ref addr) => encode_addr(w, 2, &addr.octets())?,
-            AddrV2::TorV3(ref bytes) => encode_addr(w, 4, bytes)?,
-            AddrV2::I2p(ref bytes) => encode_addr(w, 5, bytes)?,
-            AddrV2::Cjdns(ref addr) => encode_addr(w, 6, &addr.octets())?,
-            AddrV2::Unknown(network, ref bytes) => encode_addr(w, network, bytes)?,
-        })
-    }
-}
-
-impl Decodable for AddrV2 {
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        let network_id = u8::consensus_decode(r)?;
-        let len = r.read_compact_size()?;
-        if len > 512 {
-            return Err(consensus::parse_failed_error("IP must be <= 512 bytes"));
-        }
-        Ok(match network_id {
-            1 => {
-                if len != 4 {
-                    return Err(consensus::parse_failed_error("invalid IPv4 address"));
-                }
-                let addr: [u8; 4] = Decodable::consensus_decode(r)?;
-                AddrV2::Ipv4(Ipv4Addr::new(addr[0], addr[1], addr[2], addr[3]))
-            }
-            2 => {
-                if len != 16 {
-                    return Err(consensus::parse_failed_error("invalid IPv6 address"));
-                }
-                let addr: [u16; 8] = read_be_address(r)?;
-                if addr[0..3] == ONION {
-                    return Err(consensus::parse_failed_error(
-                        "OnionCat address sent with IPv6 network id",
-                    ));
-                }
-                if addr[0..6] == [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF] {
-                    return Err(consensus::parse_failed_error(
-                        "IPV4 wrapped address sent with IPv6 network id",
-                    ));
-                }
-                AddrV2::Ipv6(Ipv6Addr::new(
-                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
-                ))
-            }
-
-            4 => {
-                if len != 32 {
-                    return Err(consensus::parse_failed_error("invalid TorV3 address"));
-                }
-                let pubkey = Decodable::consensus_decode(r)?;
-                AddrV2::TorV3(pubkey)
-            }
-            5 => {
-                if len != 32 {
-                    return Err(consensus::parse_failed_error("invalid I2P address"));
-                }
-                let hash = Decodable::consensus_decode(r)?;
-                AddrV2::I2p(hash)
-            }
-            6 => {
-                if len != 16 {
-                    return Err(consensus::parse_failed_error("invalid CJDNS address"));
-                }
-                let addr: [u16; 8] = read_be_address(r)?;
-                // check the first byte for the CJDNS marker
-                if addr[0] >> 8 != 0xFC {
-                    return Err(consensus::parse_failed_error("invalid CJDNS address"));
-                }
-                AddrV2::Cjdns(Ipv6Addr::new(
-                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
-                ))
-            }
-            _ => {
-                // len already checked above to be <= 512
-                let mut addr = vec![0u8; len as usize];
-                r.read_slice(&mut addr)?;
-                AddrV2::Unknown(network_id, addr)
-            }
-        })
-    }
-}
-
-/// Address received from BIP155 addrv2 message
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct AddrV2Message {
-    /// Time that this node was last seen as connected to the network
-    pub time: u32,
-    /// Service bits
-    pub services: ServiceFlags,
-    /// Network ID + Network Address
-    pub addr: AddrV2,
-    /// Network port, 0 if not applicable
-    pub port: u16,
-}
-
-impl AddrV2Message {
-    /// Extract socket address from an [AddrV2Message] message.
-    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
-    /// if the address type can't be converted into a [SocketAddr].
-    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
-        match self.addr {
-            AddrV2::Ipv4(addr) => Ok(SocketAddr::V4(SocketAddrV4::new(addr, self.port))),
-            AddrV2::Ipv6(addr) => Ok(SocketAddr::V6(SocketAddrV6::new(addr, self.port, 0, 0))),
-            _ => Err(io::Error::from(io::ErrorKind::AddrNotAvailable)),
-        }
-    }
-}
-
-impl Encodable for AddrV2Message {
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.time.consensus_encode(w)?;
-        len += w.emit_compact_size(self.services.to_u64())?;
-        len += self.addr.consensus_encode(w)?;
-
-        w.write_all(&self.port.to_be_bytes())?;
-        len += 2; // port u16 is two bytes.
-
-        Ok(len)
-    }
-}
-
-impl Decodable for AddrV2Message {
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(AddrV2Message {
-            time: Decodable::consensus_decode(r)?,
-            services: ServiceFlags::from(r.read_compact_size()?),
-            addr: Decodable::consensus_decode(r)?,
-            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
-        })
-    }
-}
-
-impl ToSocketAddrs for AddrV2Message {
-    type Iter = iter::Once<SocketAddr>;
-    fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
-        Ok(iter::once(self.socket_addr()?))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::net::IpAddr;
-
-    use hex::FromHex;
-    use hex_lit::hex;
-
-    use super::*;
-    use crate::consensus::encode::{deserialize, serialize};
-
-    #[test]
-    fn serialize_address() {
-        assert_eq!(
-            serialize(&Address {
-                services: ServiceFlags::NETWORK,
-                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
-                port: 8333
-            }),
-            [
-                1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
-                0x20, 0x8d
-            ]
-        );
-    }
-
-    #[test]
-    fn debug_format() {
-        let mut flags = ServiceFlags::NETWORK;
-        assert_eq!(
-            format!("The address is: {:?}", Address {
-                services: flags.add(ServiceFlags::WITNESS),
-                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
-                port: 8333
-            }),
-            "The address is: Address {services: ServiceFlags(NETWORK|WITNESS), address: 10.0.0.1, port: 8333}"
-        );
-
-        assert_eq!(
-            format!("The address is: {:?}", Address {
-                services: ServiceFlags::NETWORK_LIMITED,
-                address: [0xFD87, 0xD87E, 0xEB43, 0, 0, 0xffff, 0x0a00, 0x0001],
-                port: 8333
-            }),
-            "The address is: Address {services: ServiceFlags(NETWORK_LIMITED), address: fd87:d87e:eb43::ffff:a00:1, port: 8333}"
-        );
-    }
-
-    #[test]
-    fn deserialize_address() {
-        let mut addr: Result<Address, _> = deserialize(&[
-            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
-            0x20, 0x8d,
-        ]);
-        assert!(addr.is_ok());
-        let full = addr.unwrap();
-        assert!(matches!(full.socket_addr().unwrap(), SocketAddr::V4(_)));
-        assert_eq!(full.services, ServiceFlags::NETWORK);
-        assert_eq!(full.address, [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001]);
-        assert_eq!(full.port, 8333);
-
-        addr = deserialize(&[
-            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
-        ]);
-        assert!(addr.is_err());
-    }
-
-    #[test]
-    fn socket_addr() {
-        let s4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(111, 222, 123, 4)), 5555);
-        let a4 = Address::new(&s4, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
-        assert_eq!(a4.socket_addr().unwrap(), s4);
-        let s6 = SocketAddr::new(
-            IpAddr::V6(Ipv6Addr::new(
-                0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888,
-            )),
-            9999,
-        );
-        let a6 = Address::new(&s6, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
-        assert_eq!(a6.socket_addr().unwrap(), s6);
-    }
-
-    #[test]
-    fn onion() {
-        let onionaddr = SocketAddr::new(
-            IpAddr::V6("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca".parse::<Ipv6Addr>().unwrap()),
-            1111,
-        );
-        let addr = Address::new(&onionaddr, ServiceFlags::NONE);
-        assert!(addr.socket_addr().is_err());
-    }
-
-    #[test]
-    fn serialize_addrv2() {
-        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L348
-
-        let ip = AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4));
-        assert_eq!(serialize(&ip), hex!("010401020304"));
-
-        let ip =
-            AddrV2::Ipv6("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b".parse::<Ipv6Addr>().unwrap());
-        assert_eq!(serialize(&ip), hex!("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"));
-
-        let ip = AddrV2::TorV3(
-            FromHex::from_hex("53cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
-                .unwrap(),
-        );
-        assert_eq!(
-            serialize(&ip),
-            hex!("042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
-        );
-
-        let ip = AddrV2::I2p(
-            FromHex::from_hex("a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
-                .unwrap(),
-        );
-        assert_eq!(
-            serialize(&ip),
-            hex!("0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
-        );
-
-        let ip = AddrV2::Cjdns("fc01:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap());
-        assert_eq!(serialize(&ip), hex!("0610fc010001000200030004000500060007"));
-
-        let ip = AddrV2::Unknown(170, hex!("01020304").to_vec());
-        assert_eq!(serialize(&ip), hex!("aa0401020304"));
-    }
-
-    #[test]
-    fn deserialize_addrv2() {
-        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L386
-
-        // Valid IPv4.
-        let ip: AddrV2 = deserialize(&hex!("010401020304")).unwrap();
-        assert_eq!(ip, AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4)));
-
-        // Invalid IPv4, valid length but address itself is shorter.
-        deserialize::<AddrV2>(&hex!("01040102")).unwrap_err();
-
-        // Invalid IPv4, with bogus length.
-        assert!(deserialize::<AddrV2>(&hex!("010501020304")).is_err());
-
-        // Invalid IPv4, with extreme length.
-        assert!(deserialize::<AddrV2>(&hex!("01fd010201020304")).is_err());
-
-        // Valid IPv6.
-        let ip: AddrV2 = deserialize(&hex!("02100102030405060708090a0b0c0d0e0f10")).unwrap();
-        assert_eq!(
-            ip,
-            AddrV2::Ipv6("102:304:506:708:90a:b0c:d0e:f10".parse::<Ipv6Addr>().unwrap())
-        );
-
-        // Invalid IPv6, with bogus length.
-        assert!(deserialize::<AddrV2>(&hex!("020400")).is_err());
-
-        // Invalid IPv6, contains embedded IPv4.
-        assert!(deserialize::<AddrV2>(&hex!("021000000000000000000000ffff01020304")).is_err());
-
-        // Invalid IPv6, contains embedded TORv2.
-        assert!(deserialize::<AddrV2>(&hex!("0210fd87d87eeb430102030405060708090a")).is_err());
-
-        // Valid TORv3.
-        let ip: AddrV2 = deserialize(&hex!(
-            "042079bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
-        ))
-        .unwrap();
-        assert_eq!(
-            ip,
-            AddrV2::TorV3(
-                FromHex::from_hex(
-                    "79bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
-                )
-                .unwrap()
-            )
-        );
-
-        // Invalid TORv3, with bogus length.
-        assert!(deserialize::<AddrV2>(&hex!("040000")).is_err());
-
-        // Valid I2P.
-        let ip: AddrV2 = deserialize(&hex!(
-            "0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
-        ))
-        .unwrap();
-        assert_eq!(
-            ip,
-            AddrV2::I2p(
-                FromHex::from_hex(
-                    "a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
-                )
-                .unwrap()
-            )
-        );
-
-        // Invalid I2P, with bogus length.
-        assert!(deserialize::<AddrV2>(&hex!("050300")).is_err());
-
-        // Valid CJDNS.
-        let ip: AddrV2 = deserialize(&hex!("0610fc000001000200030004000500060007")).unwrap();
-        assert_eq!(ip, AddrV2::Cjdns("fc00:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap()));
-
-        // Invalid CJDNS, incorrect marker
-        assert!(deserialize::<AddrV2>(&hex!("0610fd000001000200030004000500060007")).is_err());
-
-        // Invalid CJDNS, with bogus length.
-        assert!(deserialize::<AddrV2>(&hex!("060100")).is_err());
-
-        // Unknown, with extreme length.
-        assert!(deserialize::<AddrV2>(&hex!("aafe0000000201020304050607")).is_err());
-
-        // Unknown, with reasonable length.
-        let ip: AddrV2 = deserialize(&hex!("aa0401020304")).unwrap();
-        assert_eq!(ip, AddrV2::Unknown(170, hex!("01020304").to_vec()));
-
-        // Unknown, with zero length.
-        let ip: AddrV2 = deserialize(&hex!("aa00")).unwrap();
-        assert_eq!(ip, AddrV2::Unknown(170, vec![]));
-    }
-
-    #[test]
-    fn addrv2message() {
-        let raw = hex!("0261bc6649019902abab208d79627683fd4804010409090909208d");
-        let addresses: Vec<AddrV2Message> = deserialize(&raw).unwrap();
-
-        assert_eq!(
-            addresses,
-            vec![
-                AddrV2Message {
-                    services: ServiceFlags::NETWORK,
-                    time: 0x4966bc61,
-                    port: 8333,
-                    addr: AddrV2::Unknown(153, hex!("abab").to_vec())
-                },
-                AddrV2Message {
-                    services: ServiceFlags::NETWORK_LIMITED
-                        | ServiceFlags::WITNESS
-                        | ServiceFlags::COMPACT_FILTERS,
-                    time: 0x83766279,
-                    port: 8333,
-                    addr: AddrV2::Ipv4(Ipv4Addr::new(9, 9, 9, 9))
-                },
-            ]
-        );
-
-        assert_eq!(serialize(&addresses), raw);
-    }
-
-    #[test]
-    fn socketaddr_to_addrv2_ipv4() {
-        let socket = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 1, 1), 8333));
-        let addr = AddrV2::from(socket);
-
-        assert_eq!(addr, AddrV2::Ipv4(Ipv4Addr::new(192, 168, 1, 1)));
-    }
-
-    #[test]
-    fn socketaddr_to_addrv2_ipv6() {
-        let socket = SocketAddr::V6(SocketAddrV6::new(
-            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
-            8333,
-            0,
-            0,
-        ));
-        let addr = AddrV2::from(socket);
-
-        assert_eq!(addr, AddrV2::Ipv6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)));
-    }
-
-    #[test]
-    fn socketaddr_to_addrv2_cjdns() {
-        let socket = SocketAddr::V6(SocketAddrV6::new(
-            Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1),
-            8333,
-            0,
-            0,
-        ));
-        let addr = AddrV2::from(socket);
-
-        assert_eq!(addr, AddrV2::Cjdns(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1)));
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_ipv4() {
-        let addr = AddrV2::Ipv4(Ipv4Addr::new(192, 168, 1, 1));
-        let socket = SocketAddr::try_from(addr).unwrap();
-
-        assert_eq!(socket, SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 1, 1), 0)));
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_ipv6() {
-        let addr = AddrV2::Ipv6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
-        let socket = SocketAddr::try_from(addr).unwrap();
-
-        assert_eq!(
-            socket,
-            SocketAddr::V6(SocketAddrV6::new(
-                Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
-                0,
-                0,
-                0
-            ))
-        );
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_cjdns() {
-        let addr = AddrV2::Cjdns(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1));
-        let result = SocketAddr::try_from(addr);
-
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ConversionError::CjdnsNotRecommended);
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_torv3() {
-        let addr = AddrV2::TorV3([0; 32]);
-        let result = SocketAddr::try_from(addr);
-
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ConversionError::TorV3NotSupported);
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_i2p() {
-        let addr = AddrV2::I2p([0; 32]);
-        let result = SocketAddr::try_from(addr);
-
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ConversionError::I2pNotSupported);
-    }
-
-    #[test]
-    fn addrv2_to_socketaddr_unknown() {
-        let addr = AddrV2::Unknown(42, vec![1, 2, 3, 4]);
-        let result = SocketAddr::try_from(addr);
-
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ConversionError::UnknownNotSupported);
-    }
-}
diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
deleted file mode 100644
index bb69ec86d5..0000000000
--- a/bitcoin/src/p2p/message.rs
+++ /dev/null
@@ -1,1118 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin network messages.
-//!
-//! This module defines the `NetworkMessage` and `RawNetworkMessage` types that
-//! are used for (de)serializing Bitcoin objects for transmission on the network.
-
-use core::{fmt, iter};
-
-use hashes::sha256d;
-use internals::ToU64 as _;
-use io::{BufRead, Write};
-
-use crate::consensus::encode::{self, CheckedData, Decodable, Encodable, ReadExt, WriteExt};
-use crate::merkle_tree::MerkleBlock;
-use crate::p2p::address::{AddrV2Message, Address};
-use crate::p2p::{
-    message_blockdata, message_bloom, message_compact_blocks, message_filter, message_network,
-    Magic,
-};
-use crate::prelude::{Box, Cow, String, ToOwned, Vec};
-use crate::{block, consensus, transaction};
-
-/// The maximum number of [super::message_blockdata::Inventory] items in an `inv` message.
-///
-/// This limit is not currently enforced by this implementation.
-pub const MAX_INV_SIZE: usize = 50_000;
-
-/// Maximum size, in bytes, of an encoded message
-/// This by necessity should be larger than `MAX_VEC_SIZE`
-pub const MAX_MSG_SIZE: usize = 5_000_000;
-
-/// Serializer for command string
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CommandString(Cow<'static, str>);
-
-impl CommandString {
-    /// Converts `&'static str` to `CommandString`
-    ///
-    /// This is more efficient for string literals than non-static conversions because it avoids
-    /// allocation.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if, and only if, the string is
-    /// larger than 12 characters in length.
-    pub fn try_from_static(s: &'static str) -> Result<CommandString, CommandStringError> {
-        Self::try_from_static_cow(s.into())
-    }
-
-    fn try_from_static_cow(cow: Cow<'static, str>) -> Result<CommandString, CommandStringError> {
-        if cow.len() > 12 {
-            Err(CommandStringError { cow })
-        } else {
-            Ok(CommandString(cow))
-        }
-    }
-}
-
-impl TryFrom<String> for CommandString {
-    type Error = CommandStringError;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        Self::try_from_static_cow(value.into())
-    }
-}
-
-impl TryFrom<Box<str>> for CommandString {
-    type Error = CommandStringError;
-
-    fn try_from(value: Box<str>) -> Result<Self, Self::Error> {
-        Self::try_from_static_cow(String::from(value).into())
-    }
-}
-
-impl<'a> TryFrom<&'a str> for CommandString {
-    type Error = CommandStringError;
-
-    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
-        Self::try_from_static_cow(value.to_owned().into())
-    }
-}
-
-impl core::str::FromStr for CommandString {
-    type Err = CommandStringError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::try_from_static_cow(s.to_owned().into())
-    }
-}
-
-impl fmt::Display for CommandString {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(self.0.as_ref()) }
-}
-
-impl AsRef<str> for CommandString {
-    fn as_ref(&self) -> &str { self.0.as_ref() }
-}
-
-impl Encodable for CommandString {
-    #[inline]
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        let mut rawbytes = [0u8; 12];
-        let strbytes = self.0.as_bytes();
-        debug_assert!(strbytes.len() <= 12);
-        rawbytes[..strbytes.len()].copy_from_slice(strbytes);
-        rawbytes.consensus_encode(w)
-    }
-}
-
-impl Decodable for CommandString {
-    #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        let rawbytes: [u8; 12] = Decodable::consensus_decode(r)?;
-        let rv = iter::FromIterator::from_iter(rawbytes.iter().filter_map(|&u| {
-            if u > 0 {
-                Some(u as char)
-            } else {
-                None
-            }
-        }));
-        Ok(CommandString(rv))
-    }
-}
-
-/// Error returned when a command string is invalid.
-///
-/// This is currently returned for command strings longer than 12.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub struct CommandStringError {
-    cow: Cow<'static, str>,
-}
-
-impl fmt::Display for CommandStringError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "the command string '{}' has length {} which is larger than 12",
-            self.cow,
-            self.cow.len()
-        )
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for CommandStringError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
-}
-
-/// A Network message using the v1 p2p protocol.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct RawNetworkMessage {
-    magic: Magic,
-    payload: NetworkMessage,
-    payload_len: u32,
-    checksum: [u8; 4],
-}
-
-/// A Network message using the v2 p2p protocol defined in BIP324.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct V2NetworkMessage {
-    payload: NetworkMessage,
-}
-
-/// A Network message payload. Proper documentation is available on at
-/// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum NetworkMessage {
-    /// `version`
-    Version(message_network::VersionMessage),
-    /// `verack`
-    Verack,
-    /// `addr`
-    Addr(Vec<(u32, Address)>),
-    /// `inv`
-    Inv(Vec<message_blockdata::Inventory>),
-    /// `getdata`
-    GetData(Vec<message_blockdata::Inventory>),
-    /// `notfound`
-    NotFound(Vec<message_blockdata::Inventory>),
-    /// `getblocks`
-    GetBlocks(message_blockdata::GetBlocksMessage),
-    /// `getheaders`
-    GetHeaders(message_blockdata::GetHeadersMessage),
-    /// `mempool`
-    MemPool,
-    /// tx
-    Tx(transaction::Transaction),
-    /// `block`
-    Block(block::Block),
-    /// `headers`
-    Headers(Vec<block::Header>),
-    /// `sendheaders`
-    SendHeaders,
-    /// `getaddr`
-    GetAddr,
-    /// `ping`
-    Ping(u64),
-    /// `pong`
-    Pong(u64),
-    /// `merkleblock`
-    MerkleBlock(MerkleBlock),
-    /// BIP 37 `filterload`
-    FilterLoad(message_bloom::FilterLoad),
-    /// BIP 37 `filteradd`
-    FilterAdd(message_bloom::FilterAdd),
-    /// BIP 37 `filterclear`
-    FilterClear,
-    /// BIP157 getcfilters
-    GetCFilters(message_filter::GetCFilters),
-    /// BIP157 cfilter
-    CFilter(message_filter::CFilter),
-    /// BIP157 getcfheaders
-    GetCFHeaders(message_filter::GetCFHeaders),
-    /// BIP157 cfheaders
-    CFHeaders(message_filter::CFHeaders),
-    /// BIP157 getcfcheckpt
-    GetCFCheckpt(message_filter::GetCFCheckpt),
-    /// BIP157 cfcheckpt
-    CFCheckpt(message_filter::CFCheckpt),
-    /// BIP152 sendcmpct
-    SendCmpct(message_compact_blocks::SendCmpct),
-    /// BIP152 cmpctblock
-    CmpctBlock(message_compact_blocks::CmpctBlock),
-    /// BIP152 getblocktxn
-    GetBlockTxn(message_compact_blocks::GetBlockTxn),
-    /// BIP152 blocktxn
-    BlockTxn(message_compact_blocks::BlockTxn),
-    /// `alert`
-    Alert(Vec<u8>),
-    /// `reject`
-    Reject(message_network::Reject),
-    /// `feefilter`
-    FeeFilter(i64),
-    /// `wtxidrelay`
-    WtxidRelay,
-    /// `addrv2`
-    AddrV2(Vec<AddrV2Message>),
-    /// `sendaddrv2`
-    SendAddrV2,
-
-    /// Any other message.
-    Unknown {
-        /// The command of this message.
-        command: CommandString,
-        /// The payload of this message.
-        payload: Vec<u8>,
-    },
-}
-
-impl NetworkMessage {
-    /// Return the message command as a static string reference.
-    ///
-    /// This returns `"unknown"` for [NetworkMessage::Unknown],
-    /// regardless of the actual command in the unknown message.
-    /// Use the [Self::command] method to get the command for unknown messages.
-    pub fn cmd(&self) -> &'static str {
-        match *self {
-            NetworkMessage::Version(_) => "version",
-            NetworkMessage::Verack => "verack",
-            NetworkMessage::Addr(_) => "addr",
-            NetworkMessage::Inv(_) => "inv",
-            NetworkMessage::GetData(_) => "getdata",
-            NetworkMessage::NotFound(_) => "notfound",
-            NetworkMessage::GetBlocks(_) => "getblocks",
-            NetworkMessage::GetHeaders(_) => "getheaders",
-            NetworkMessage::MemPool => "mempool",
-            NetworkMessage::Tx(_) => "tx",
-            NetworkMessage::Block(_) => "block",
-            NetworkMessage::Headers(_) => "headers",
-            NetworkMessage::SendHeaders => "sendheaders",
-            NetworkMessage::GetAddr => "getaddr",
-            NetworkMessage::Ping(_) => "ping",
-            NetworkMessage::Pong(_) => "pong",
-            NetworkMessage::MerkleBlock(_) => "merkleblock",
-            NetworkMessage::FilterLoad(_) => "filterload",
-            NetworkMessage::FilterAdd(_) => "filteradd",
-            NetworkMessage::FilterClear => "filterclear",
-            NetworkMessage::GetCFilters(_) => "getcfilters",
-            NetworkMessage::CFilter(_) => "cfilter",
-            NetworkMessage::GetCFHeaders(_) => "getcfheaders",
-            NetworkMessage::CFHeaders(_) => "cfheaders",
-            NetworkMessage::GetCFCheckpt(_) => "getcfcheckpt",
-            NetworkMessage::CFCheckpt(_) => "cfcheckpt",
-            NetworkMessage::SendCmpct(_) => "sendcmpct",
-            NetworkMessage::CmpctBlock(_) => "cmpctblock",
-            NetworkMessage::GetBlockTxn(_) => "getblocktxn",
-            NetworkMessage::BlockTxn(_) => "blocktxn",
-            NetworkMessage::Alert(_) => "alert",
-            NetworkMessage::Reject(_) => "reject",
-            NetworkMessage::FeeFilter(_) => "feefilter",
-            NetworkMessage::WtxidRelay => "wtxidrelay",
-            NetworkMessage::AddrV2(_) => "addrv2",
-            NetworkMessage::SendAddrV2 => "sendaddrv2",
-            NetworkMessage::Unknown { .. } => "unknown",
-        }
-    }
-
-    /// Return the CommandString for the message command.
-    pub fn command(&self) -> CommandString {
-        match *self {
-            NetworkMessage::Unknown { command: ref c, .. } => c.clone(),
-            _ => CommandString::try_from_static(self.cmd()).expect("cmd returns valid commands"),
-        }
-    }
-}
-
-impl RawNetworkMessage {
-    /// Constructs a new [RawNetworkMessage]
-    pub fn new(magic: Magic, payload: NetworkMessage) -> Self {
-        let mut engine = sha256d::Hash::engine();
-        let payload_len = payload.consensus_encode(&mut engine).expect("engine doesn't error");
-        let payload_len = u32::try_from(payload_len).expect("network message use u32 as length");
-        let checksum = sha256d::Hash::from_engine(engine);
-        let checksum = checksum.to_byte_array();
-        let checksum = [checksum[0], checksum[1], checksum[2], checksum[3]];
-        Self { magic, payload, payload_len, checksum }
-    }
-
-    /// Consumes the [RawNetworkMessage] instance and returns the inner payload.
-    pub fn into_payload(self) -> NetworkMessage { self.payload }
-
-    /// The actual message data
-    pub fn payload(&self) -> &NetworkMessage { &self.payload }
-
-    /// Magic bytes to identify the network these messages are meant for
-    pub fn magic(&self) -> &Magic { &self.magic }
-
-    /// Return the message command as a static string reference.
-    ///
-    /// This returns `"unknown"` for [NetworkMessage::Unknown],
-    /// regardless of the actual command in the unknown message.
-    /// Use the [Self::command] method to get the command for unknown messages.
-    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
-
-    /// Return the CommandString for the message command.
-    pub fn command(&self) -> CommandString { self.payload.command() }
-}
-
-impl V2NetworkMessage {
-    /// Constructs a new [V2NetworkMessage].
-    pub fn new(payload: NetworkMessage) -> Self { Self { payload } }
-
-    /// Consumes the [V2NetworkMessage] instance and returns the inner payload.
-    pub fn into_payload(self) -> NetworkMessage { self.payload }
-
-    /// The actual message data
-    pub fn payload(&self) -> &NetworkMessage { &self.payload }
-
-    /// Return the message command as a static string reference.
-    ///
-    /// This returns `"unknown"` for [NetworkMessage::Unknown],
-    /// regardless of the actual command in the unknown message.
-    /// Use the [Self::command] method to get the command for unknown messages.
-    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
-
-    /// Return the CommandString for the message command.
-    pub fn command(&self) -> CommandString { self.payload.command() }
-}
-
-struct HeaderSerializationWrapper<'a>(&'a Vec<block::Header>);
-
-impl Encodable for HeaderSerializationWrapper<'_> {
-    #[inline]
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        let mut len = 0;
-        len += w.emit_compact_size(self.0.len())?;
-        for header in self.0.iter() {
-            len += header.consensus_encode(w)?;
-            len += 0u8.consensus_encode(w)?;
-        }
-        Ok(len)
-    }
-}
-
-impl Encodable for NetworkMessage {
-    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
-        match self {
-            NetworkMessage::Version(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Addr(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Inv(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetData(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::NotFound(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetBlocks(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Tx(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Block(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Headers(ref dat) =>
-                HeaderSerializationWrapper(dat).consensus_encode(writer),
-            NetworkMessage::Ping(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Pong(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::MerkleBlock(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FilterLoad(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FilterAdd(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFilters(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFilter(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFHeaders(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetCFCheckpt(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CFCheckpt(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::SendCmpct(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::CmpctBlock(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::GetBlockTxn(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::BlockTxn(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Alert(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Reject(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::FeeFilter(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::AddrV2(ref dat) => dat.consensus_encode(writer),
-            NetworkMessage::Verack
-            | NetworkMessage::SendHeaders
-            | NetworkMessage::MemPool
-            | NetworkMessage::GetAddr
-            | NetworkMessage::WtxidRelay
-            | NetworkMessage::FilterClear
-            | NetworkMessage::SendAddrV2 => Ok(0),
-            NetworkMessage::Unknown { payload: ref data, .. } => data.consensus_encode(writer),
-        }
-    }
-}
-
-impl Encodable for RawNetworkMessage {
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        let mut len = 0;
-        len += self.magic.consensus_encode(w)?;
-        len += self.command().consensus_encode(w)?;
-        len += self.payload_len.consensus_encode(w)?;
-        len += self.checksum.consensus_encode(w)?;
-        len += self.payload().consensus_encode(w)?;
-        Ok(len)
-    }
-}
-
-impl Encodable for V2NetworkMessage {
-    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
-        // A subset of message types are optimized to only use one byte to encode the command.
-        // Non-optimized message types use the zero-byte flag and the following twelve bytes to encode the command.
-        let (command_byte, full_command) = match self.payload {
-            NetworkMessage::Addr(_) => (1u8, None),
-            NetworkMessage::Inv(_) => (14u8, None),
-            NetworkMessage::GetData(_) => (11u8, None),
-            NetworkMessage::NotFound(_) => (17u8, None),
-            NetworkMessage::GetBlocks(_) => (9u8, None),
-            NetworkMessage::GetHeaders(_) => (12u8, None),
-            NetworkMessage::MemPool => (15u8, None),
-            NetworkMessage::Tx(_) => (21u8, None),
-            NetworkMessage::Block(_) => (2u8, None),
-            NetworkMessage::Headers(_) => (13u8, None),
-            NetworkMessage::Ping(_) => (18u8, None),
-            NetworkMessage::Pong(_) => (19u8, None),
-            NetworkMessage::MerkleBlock(_) => (16u8, None),
-            NetworkMessage::FilterLoad(_) => (8u8, None),
-            NetworkMessage::FilterAdd(_) => (6u8, None),
-            NetworkMessage::FilterClear => (7u8, None),
-            NetworkMessage::GetCFilters(_) => (22u8, None),
-            NetworkMessage::CFilter(_) => (23u8, None),
-            NetworkMessage::GetCFHeaders(_) => (24u8, None),
-            NetworkMessage::CFHeaders(_) => (25u8, None),
-            NetworkMessage::GetCFCheckpt(_) => (26u8, None),
-            NetworkMessage::CFCheckpt(_) => (27u8, None),
-            NetworkMessage::SendCmpct(_) => (20u8, None),
-            NetworkMessage::CmpctBlock(_) => (4u8, None),
-            NetworkMessage::GetBlockTxn(_) => (10u8, None),
-            NetworkMessage::BlockTxn(_) => (3u8, None),
-            NetworkMessage::FeeFilter(_) => (5u8, None),
-            NetworkMessage::AddrV2(_) => (28u8, None),
-            NetworkMessage::Version(_)
-            | NetworkMessage::Verack
-            | NetworkMessage::SendHeaders
-            | NetworkMessage::GetAddr
-            | NetworkMessage::WtxidRelay
-            | NetworkMessage::SendAddrV2
-            | NetworkMessage::Alert(_)
-            | NetworkMessage::Reject(_)
-            | NetworkMessage::Unknown { .. } => (0u8, Some(self.payload.command())),
-        };
-
-        let mut len = command_byte.consensus_encode(writer)?;
-        if let Some(cmd) = full_command {
-            len += cmd.consensus_encode(writer)?;
-        }
-
-        // Encode the payload.
-        len += self.payload.consensus_encode(writer)?;
-
-        Ok(len)
-    }
-}
-
-struct HeaderDeserializationWrapper(Vec<block::Header>);
-
-impl Decodable for HeaderDeserializationWrapper {
-    #[inline]
-    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
-        r: &mut R,
-    ) -> Result<Self, encode::Error> {
-        let len = r.read_compact_size()?;
-        // should be above usual number of items to avoid
-        // allocation
-        let mut ret = Vec::with_capacity(core::cmp::min(1024 * 16, len as usize));
-        for _ in 0..len {
-            ret.push(Decodable::consensus_decode(r)?);
-            if u8::consensus_decode(r)? != 0u8 {
-                return Err(consensus::parse_failed_error(
-                    "Headers message should not contain transactions",
-                ));
-            }
-        }
-        Ok(HeaderDeserializationWrapper(ret))
-    }
-
-    #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
-    }
-}
-
-impl Decodable for RawNetworkMessage {
-    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
-        r: &mut R,
-    ) -> Result<Self, encode::Error> {
-        let magic = Decodable::consensus_decode_from_finite_reader(r)?;
-        let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
-        let checked_data = CheckedData::consensus_decode_from_finite_reader(r)?;
-        let checksum = checked_data.checksum();
-        let raw_payload = checked_data.into_data();
-        let payload_len = raw_payload.len() as u32;
-
-        let mut mem_d = raw_payload.as_slice();
-        let payload = match &cmd.0[..] {
-            "version" =>
-                NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "verack" => NetworkMessage::Verack,
-            "addr" =>
-                NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "inv" =>
-                NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "getdata" =>
-                NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "notfound" => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(
-                &mut mem_d,
-            )?),
-            "getblocks" => NetworkMessage::GetBlocks(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "getheaders" => NetworkMessage::GetHeaders(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "mempool" => NetworkMessage::MemPool,
-            "block" =>
-                NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "headers" => NetworkMessage::Headers(
-                HeaderDeserializationWrapper::consensus_decode_from_finite_reader(&mut mem_d)?.0,
-            ),
-            "sendheaders" => NetworkMessage::SendHeaders,
-            "getaddr" => NetworkMessage::GetAddr,
-            "ping" =>
-                NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "pong" =>
-                NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "merkleblock" => NetworkMessage::MerkleBlock(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "filterload" => NetworkMessage::FilterLoad(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "filteradd" => NetworkMessage::FilterAdd(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "filterclear" => NetworkMessage::FilterClear,
-            "tx" => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "getcfilters" => NetworkMessage::GetCFilters(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "cfilter" =>
-                NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "getcfheaders" => NetworkMessage::GetCFHeaders(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "cfheaders" => NetworkMessage::CFHeaders(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "getcfcheckpt" => NetworkMessage::GetCFCheckpt(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "cfcheckpt" => NetworkMessage::CFCheckpt(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "reject" =>
-                NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "alert" =>
-                NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "feefilter" => NetworkMessage::FeeFilter(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "sendcmpct" => NetworkMessage::SendCmpct(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "cmpctblock" => NetworkMessage::CmpctBlock(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "getblocktxn" => NetworkMessage::GetBlockTxn(
-                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
-            ),
-            "blocktxn" => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(
-                &mut mem_d,
-            )?),
-            "wtxidrelay" => NetworkMessage::WtxidRelay,
-            "addrv2" =>
-                NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
-            "sendaddrv2" => NetworkMessage::SendAddrV2,
-            _ => NetworkMessage::Unknown { command: cmd, payload: raw_payload },
-        };
-        Ok(RawNetworkMessage { magic, payload, payload_len, checksum })
-    }
-
-    #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
-    }
-}
-
-impl Decodable for V2NetworkMessage {
-    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
-        r: &mut R,
-    ) -> Result<Self, encode::Error> {
-        let short_id: u8 = Decodable::consensus_decode_from_finite_reader(r)?;
-        let payload = match short_id {
-            0u8 => {
-                // Full command encoding.
-                let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
-                match &cmd.0[..] {
-                    "version" =>
-                        NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(r)?),
-                    "verack" => NetworkMessage::Verack,
-                    "sendheaders" => NetworkMessage::SendHeaders,
-                    "getaddr" => NetworkMessage::GetAddr,
-                    "wtxidrelay" => NetworkMessage::WtxidRelay,
-                    "sendaddrv2" => NetworkMessage::SendAddrV2,
-                    "alert" =>
-                        NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(r)?),
-                    "reject" =>
-                        NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(r)?),
-                    _ => NetworkMessage::Unknown {
-                        command: cmd,
-                        payload: Vec::consensus_decode_from_finite_reader(r)?,
-                    },
-                }
-            }
-            1u8 => NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(r)?),
-            2u8 => NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(r)?),
-            3u8 => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
-            4u8 => NetworkMessage::CmpctBlock(Decodable::consensus_decode_from_finite_reader(r)?),
-            5u8 => NetworkMessage::FeeFilter(Decodable::consensus_decode_from_finite_reader(r)?),
-            6u8 => NetworkMessage::FilterAdd(Decodable::consensus_decode_from_finite_reader(r)?),
-            7u8 => NetworkMessage::FilterClear,
-            8u8 => NetworkMessage::FilterLoad(Decodable::consensus_decode_from_finite_reader(r)?),
-            9u8 => NetworkMessage::GetBlocks(Decodable::consensus_decode_from_finite_reader(r)?),
-            10u8 => NetworkMessage::GetBlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
-            11u8 => NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(r)?),
-            12u8 => NetworkMessage::GetHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
-            13u8 => NetworkMessage::Headers(
-                HeaderDeserializationWrapper::consensus_decode_from_finite_reader(r)?.0,
-            ),
-            14u8 => NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(r)?),
-            15u8 => NetworkMessage::MemPool,
-            16u8 => NetworkMessage::MerkleBlock(Decodable::consensus_decode_from_finite_reader(r)?),
-            17u8 => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(r)?),
-            18u8 => NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(r)?),
-            19u8 => NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(r)?),
-            20u8 => NetworkMessage::SendCmpct(Decodable::consensus_decode_from_finite_reader(r)?),
-            21u8 => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(r)?),
-            22u8 => NetworkMessage::GetCFilters(Decodable::consensus_decode_from_finite_reader(r)?),
-            23u8 => NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(r)?),
-            24u8 =>
-                NetworkMessage::GetCFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
-            25u8 => NetworkMessage::CFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
-            26u8 =>
-                NetworkMessage::GetCFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
-            27u8 => NetworkMessage::CFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
-            28u8 => NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(r)?),
-            _ =>
-                return Err(encode::Error::Parse(encode::ParseError::ParseFailed(
-                    "Unknown short ID",
-                ))),
-        };
-        Ok(V2NetworkMessage { payload })
-    }
-
-    #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::net::Ipv4Addr;
-
-    use hex_lit::hex;
-    use units::BlockHeight;
-
-    use super::*;
-    use crate::bip152::BlockTransactionsRequest;
-    use crate::bip158::{FilterHash, FilterHeader};
-    use crate::block::{Block, BlockHash};
-    use crate::consensus::encode::{deserialize, deserialize_partial, serialize};
-    use crate::p2p::address::AddrV2;
-    use crate::p2p::message_blockdata::{GetBlocksMessage, GetHeadersMessage, Inventory};
-    use crate::p2p::message_bloom::{BloomFlags, FilterAdd, FilterLoad};
-    use crate::p2p::message_compact_blocks::{GetBlockTxn, SendCmpct};
-    use crate::p2p::message_filter::{
-        CFCheckpt, CFHeaders, CFilter, GetCFCheckpt, GetCFHeaders, GetCFilters,
-    };
-    use crate::p2p::message_network::{Reject, RejectReason, VersionMessage};
-    use crate::p2p::ServiceFlags;
-    use crate::script::ScriptBuf;
-    use crate::transaction::{Transaction, Txid};
-
-    fn hash(array: [u8; 32]) -> sha256d::Hash { sha256d::Hash::from_byte_array(array) }
-
-    #[test]
-    fn full_round_ser_der_raw_network_message() {
-        let version_msg: VersionMessage = deserialize(&hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001")).unwrap();
-        let tx: Transaction = deserialize(&hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000")).unwrap();
-        let block: Block = deserialize(&include_bytes!("../../tests/data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw")[..]).unwrap();
-        let header: block::Header = deserialize(&hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b")).unwrap();
-        let script: ScriptBuf =
-            deserialize(&hex!("1976a91431a420903c05a0a7de2de40c9f02ebedbacdc17288ac")).unwrap();
-        let merkle_block: MerkleBlock = deserialize(&hex!("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101")).unwrap();
-        let cmptblock = deserialize(&hex!("00000030d923ad36ff2d955abab07f8a0a6e813bc6e066b973e780c5e36674cad5d1cd1f6e265f2a17a0d35cbe701fe9d06e2c6324cfe135f6233e8b767bfa3fb4479b71115dc562ffff7f2006000000000000000000000000010002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0302ee00ffffffff0100f9029500000000015100000000")).unwrap();
-        let blocktxn = deserialize(&hex!("2e93c0cff39ff605020072d96bc3a8d20b8447e294d08092351c8583e08d9b5a01020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0402dc0000ffffffff0200f90295000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap();
-
-        let msgs = [
-            NetworkMessage::Version(version_msg),
-            NetworkMessage::Verack,
-            NetworkMessage::Addr(vec![(
-                45,
-                Address::new(&([123, 255, 000, 100], 833).into(), ServiceFlags::NETWORK),
-            )]),
-            NetworkMessage::Inv(vec![Inventory::Block(BlockHash::from_byte_array(
-                hash([8u8; 32]).to_byte_array(),
-            ))]),
-            NetworkMessage::GetData(vec![Inventory::Transaction(Txid::from_byte_array(
-                hash([45u8; 32]).to_byte_array(),
-            ))]),
-            NetworkMessage::NotFound(vec![Inventory::Error([0u8; 32])]),
-            NetworkMessage::GetBlocks(GetBlocksMessage::new(
-                vec![
-                    BlockHash::from_byte_array(hash([1u8; 32]).to_byte_array()),
-                    BlockHash::from_byte_array(hash([4u8; 32]).to_byte_array()),
-                ],
-                BlockHash::from_byte_array(hash([5u8; 32]).to_byte_array()),
-            )),
-            NetworkMessage::GetHeaders(GetHeadersMessage::new(
-                vec![
-                    BlockHash::from_byte_array(hash([10u8; 32]).to_byte_array()),
-                    BlockHash::from_byte_array(hash([40u8; 32]).to_byte_array()),
-                ],
-                BlockHash::from_byte_array(hash([50u8; 32]).to_byte_array()),
-            )),
-            NetworkMessage::MemPool,
-            NetworkMessage::Tx(tx),
-            NetworkMessage::Block(block),
-            NetworkMessage::Headers(vec![header]),
-            NetworkMessage::SendHeaders,
-            NetworkMessage::GetAddr,
-            NetworkMessage::Ping(15),
-            NetworkMessage::Pong(23),
-            NetworkMessage::MerkleBlock(merkle_block),
-            NetworkMessage::FilterLoad(FilterLoad {
-                filter: hex!("03614e9b050000000000000001").to_vec(),
-                hash_funcs: 1,
-                tweak: 2,
-                flags: BloomFlags::All,
-            }),
-            NetworkMessage::FilterAdd(FilterAdd { data: script.as_bytes().to_vec() }),
-            NetworkMessage::FilterAdd(FilterAdd {
-                data: hash([29u8; 32]).as_byte_array().to_vec(),
-            }),
-            NetworkMessage::FilterClear,
-            NetworkMessage::GetCFilters(GetCFilters {
-                filter_type: 2,
-                start_height: BlockHeight::from(52),
-                stop_hash: BlockHash::from_byte_array(hash([42u8; 32]).to_byte_array()),
-            }),
-            NetworkMessage::CFilter(CFilter {
-                filter_type: 7,
-                block_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
-                filter: vec![1, 2, 3],
-            }),
-            NetworkMessage::GetCFHeaders(GetCFHeaders {
-                filter_type: 4,
-                start_height: BlockHeight::from(102),
-                stop_hash: BlockHash::from_byte_array(hash([47u8; 32]).to_byte_array()),
-            }),
-            NetworkMessage::CFHeaders(CFHeaders {
-                filter_type: 13,
-                stop_hash: BlockHash::from_byte_array(hash([53u8; 32]).to_byte_array()),
-                previous_filter_header: FilterHeader::from_byte_array(
-                    hash([12u8; 32]).to_byte_array(),
-                ),
-                filter_hashes: vec![
-                    FilterHash::from_byte_array(hash([4u8; 32]).to_byte_array()),
-                    FilterHash::from_byte_array(hash([12u8; 32]).to_byte_array()),
-                ],
-            }),
-            NetworkMessage::GetCFCheckpt(GetCFCheckpt {
-                filter_type: 17,
-                stop_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
-            }),
-            NetworkMessage::CFCheckpt(CFCheckpt {
-                filter_type: 27,
-                stop_hash: BlockHash::from_byte_array(hash([77u8; 32]).to_byte_array()),
-                filter_headers: vec![
-                    FilterHeader::from_byte_array(hash([3u8; 32]).to_byte_array()),
-                    FilterHeader::from_byte_array(hash([99u8; 32]).to_byte_array()),
-                ],
-            }),
-            NetworkMessage::Alert(vec![45, 66, 3, 2, 6, 8, 9, 12, 3, 130]),
-            NetworkMessage::Reject(Reject {
-                message: "Test reject".into(),
-                ccode: RejectReason::Duplicate,
-                reason: "Cause".into(),
-                hash: hash([255u8; 32]),
-            }),
-            NetworkMessage::FeeFilter(1000),
-            NetworkMessage::WtxidRelay,
-            NetworkMessage::AddrV2(vec![AddrV2Message {
-                addr: AddrV2::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
-                port: 0,
-                services: ServiceFlags::NONE,
-                time: 0,
-            }]),
-            NetworkMessage::SendAddrV2,
-            NetworkMessage::CmpctBlock(cmptblock),
-            NetworkMessage::GetBlockTxn(GetBlockTxn {
-                txs_request: BlockTransactionsRequest {
-                    block_hash: BlockHash::from_byte_array(hash([11u8; 32]).to_byte_array()),
-                    indexes: vec![0, 1, 2, 3, 10, 3002],
-                },
-            }),
-            NetworkMessage::BlockTxn(blocktxn),
-            NetworkMessage::SendCmpct(SendCmpct { send_compact: true, version: 8333 }),
-        ];
-
-        for msg in &msgs {
-            // V1 messages.
-            let raw_msg = RawNetworkMessage::new(Magic::from_bytes([57, 0, 0, 0]), msg.clone());
-            assert_eq!(deserialize::<RawNetworkMessage>(&serialize(&raw_msg)).unwrap(), raw_msg);
-
-            // V2 messages.
-            let v2_msg = V2NetworkMessage::new(msg.clone());
-            assert_eq!(deserialize::<V2NetworkMessage>(&serialize(&v2_msg)).unwrap(), v2_msg);
-        }
-    }
-
-    #[test]
-    fn commandstring() {
-        // Test converting.
-        assert_eq!(
-            CommandString::try_from_static("AndrewAndrew").unwrap().as_ref(),
-            "AndrewAndrew"
-        );
-        assert!(CommandString::try_from_static("AndrewAndrewA").is_err());
-
-        // Test serializing.
-        let cs = CommandString("Andrew".into());
-        assert_eq!(serialize(&cs), [0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
-
-        // Test deserializing
-        let cs: Result<CommandString, _> =
-            deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
-        assert!(cs.is_ok());
-        assert_eq!(cs.as_ref().unwrap().to_string(), "Andrew".to_owned());
-        assert_eq!(cs.unwrap(), CommandString::try_from_static("Andrew").unwrap());
-
-        let short_cs: Result<CommandString, _> =
-            deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0]);
-        assert!(short_cs.is_err());
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_verack() {
-        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::Verack)),
-                       [0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x61,
-                        0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn serialize_v2_verack() {
-        assert_eq!(
-            serialize(&V2NetworkMessage::new(NetworkMessage::Verack)),
-            [
-                0x00, // Full command encoding flag.
-                0x76, 0x65, 0x72, 0x61, 0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ]
-        );
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_ping() {
-        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::Ping(100))),
-                       [0xf9, 0xbe, 0xb4, 0xd9, 0x70, 0x69, 0x6e, 0x67,
-                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                        0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
-                        0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
-    }
-
-    #[test]
-    fn serialize_v2_ping() {
-        assert_eq!(
-            serialize(&V2NetworkMessage::new(NetworkMessage::Ping(100))),
-            [
-                0x12, // Ping command short ID
-                0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ]
-        );
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_mempool() {
-        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::MemPool)),
-                       [0xf9, 0xbe, 0xb4, 0xd9, 0x6d, 0x65, 0x6d, 0x70,
-                        0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
-                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn serialize_v2_mempool() {
-        assert_eq!(
-            serialize(&V2NetworkMessage::new(NetworkMessage::MemPool)),
-            [
-                0x0F, // MemPool command short ID
-            ]
-        );
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_getaddr() {
-        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::GetAddr)),
-                       [0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
-                        0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn serialize_v2_getaddr() {
-        assert_eq!(
-            serialize(&V2NetworkMessage::new(NetworkMessage::GetAddr)),
-            [
-                0x00, // Full command encoding flag.
-                0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ]
-        );
-    }
-
-    #[test]
-    fn deserialize_getaddr() {
-        #[rustfmt::skip]
-        let msg = deserialize(&[
-            0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
-            0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2
-        ]);
-        let preimage = RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::GetAddr);
-        assert!(msg.is_ok());
-        let msg: RawNetworkMessage = msg.unwrap();
-        assert_eq!(preimage.magic, msg.magic);
-        assert_eq!(preimage.payload, msg.payload);
-    }
-
-    #[test]
-    fn deserialize_v2_getaddr() {
-        let msg = deserialize(&[
-            0x00, // Full command encoding flag
-            0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-        ]);
-
-        let preimage = V2NetworkMessage::new(NetworkMessage::GetAddr);
-        assert!(msg.is_ok());
-        let msg: V2NetworkMessage = msg.unwrap();
-        assert_eq!(preimage, msg);
-    }
-
-    #[test]
-    fn deserialize_version() {
-        #[rustfmt::skip]
-        let msg = deserialize::<RawNetworkMessage>(&[
-            0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
-            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
-            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
-            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
-            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
-            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01
-        ]);
-
-        assert!(msg.is_ok());
-        let msg = msg.unwrap();
-        assert_eq!(msg.magic, Magic::BITCOIN);
-        if let NetworkMessage::Version(version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(
-                version_msg.services,
-                ServiceFlags::NETWORK
-                    | ServiceFlags::BLOOM
-                    | ServiceFlags::WITNESS
-                    | ServiceFlags::NETWORK_LIMITED
-            );
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert!(version_msg.relay);
-        } else {
-            panic!("wrong message type");
-        }
-    }
-
-    #[test]
-    fn deserialize_v2_version() {
-        #[rustfmt::skip]
-        let msg = deserialize::<V2NetworkMessage>(&[
-            0x00, // Full command encoding flag
-            0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, // "version" command
-            0x7f, 0x11, 0x01, 0x00, // version: 70015
-            0x0d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // services
-            0xf0, 0x0f, 0x4d, 0x5c, 0x00, 0x00, 0x00, 0x00, // timestamp: 1548554224
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // receiver services: NONE
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, // addr_recv
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sender services: NONE
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // addr_from
-            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1, // nonce
-            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31, 0x2f, // user_agent: "/Satoshi:0.17.1/"
-            0x93, 0x8c, 0x08, 0x00, // start_height: 560275
-            0x01 // relay: true
-        ]).unwrap();
-
-        if let NetworkMessage::Version(version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(
-                version_msg.services,
-                ServiceFlags::NETWORK
-                    | ServiceFlags::BLOOM
-                    | ServiceFlags::WITNESS
-                    | ServiceFlags::NETWORK_LIMITED
-            );
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert!(version_msg.relay);
-        } else {
-            panic!("wrong message type");
-        }
-    }
-
-    #[test]
-    fn deserialize_partial_message() {
-        #[rustfmt::skip]
-        let data = [
-            0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
-            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
-            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
-            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
-            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
-            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01, 0x00, 0x00
-        ];
-        let msg = deserialize_partial::<RawNetworkMessage>(&data);
-        assert!(msg.is_ok());
-
-        let (msg, consumed) = msg.unwrap();
-        assert_eq!(consumed, data.to_vec().len() - 2);
-        assert_eq!(msg.magic, Magic::BITCOIN);
-        if let NetworkMessage::Version(version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(
-                version_msg.services,
-                ServiceFlags::NETWORK
-                    | ServiceFlags::BLOOM
-                    | ServiceFlags::WITNESS
-                    | ServiceFlags::NETWORK_LIMITED
-            );
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert!(version_msg.relay);
-        } else {
-            panic!("wrong message type");
-        }
-    }
-}
diff --git a/bitcoin/src/p2p/message_filter.rs b/bitcoin/src/p2p/message_filter.rs
deleted file mode 100644
index 344e2d0a8b..0000000000
--- a/bitcoin/src/p2p/message_filter.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin Client Side Block Filtering network messages.
-//!
-//! This module describes BIP157 Client Side Block Filtering network messages.
-
-use units::BlockHeight;
-
-use crate::bip158::{FilterHash, FilterHeader};
-use crate::block::BlockHash;
-use crate::internal_macros::impl_consensus_encoding;
-
-/// getcfilters message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct GetCFilters {
-    /// Filter type for which headers are requested
-    pub filter_type: u8,
-    /// The height of the first block in the requested range
-    pub start_height: BlockHeight,
-    /// The hash of the last block in the requested range
-    pub stop_hash: BlockHash,
-}
-impl_consensus_encoding!(GetCFilters, filter_type, start_height, stop_hash);
-
-/// cfilter message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CFilter {
-    /// Byte identifying the type of filter being returned
-    pub filter_type: u8,
-    /// Block hash of the Bitcoin block for which the filter is being returned
-    pub block_hash: BlockHash,
-    /// The serialized compact filter for this block
-    pub filter: Vec<u8>,
-}
-impl_consensus_encoding!(CFilter, filter_type, block_hash, filter);
-
-/// getcfheaders message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct GetCFHeaders {
-    /// Byte identifying the type of filter being returned
-    pub filter_type: u8,
-    /// The height of the first block in the requested range
-    pub start_height: BlockHeight,
-    /// The hash of the last block in the requested range
-    pub stop_hash: BlockHash,
-}
-impl_consensus_encoding!(GetCFHeaders, filter_type, start_height, stop_hash);
-
-/// cfheaders message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CFHeaders {
-    /// Filter type for which headers are requested
-    pub filter_type: u8,
-    /// The hash of the last block in the requested range
-    pub stop_hash: BlockHash,
-    /// The filter header preceding the first block in the requested range
-    pub previous_filter_header: FilterHeader,
-    /// The filter hashes for each block in the requested range
-    pub filter_hashes: Vec<FilterHash>,
-}
-impl_consensus_encoding!(CFHeaders, filter_type, stop_hash, previous_filter_header, filter_hashes);
-
-/// getcfcheckpt message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct GetCFCheckpt {
-    /// Filter type for which headers are requested
-    pub filter_type: u8,
-    /// The hash of the last block in the requested range
-    pub stop_hash: BlockHash,
-}
-impl_consensus_encoding!(GetCFCheckpt, filter_type, stop_hash);
-
-/// cfcheckpt message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CFCheckpt {
-    /// Filter type for which headers are requested
-    pub filter_type: u8,
-    /// The hash of the last block in the requested range
-    pub stop_hash: BlockHash,
-    /// The filter headers at intervals of 1,000
-    pub filter_headers: Vec<FilterHeader>,
-}
-impl_consensus_encoding!(CFCheckpt, filter_type, stop_hash, filter_headers);
diff --git a/bitcoin/src/p2p/message_network.rs b/bitcoin/src/p2p/message_network.rs
deleted file mode 100644
index d4a41b9e1c..0000000000
--- a/bitcoin/src/p2p/message_network.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin network-related network messages.
-//!
-//! This module defines network messages which describe peers and their
-//! capabilities.
-
-use hashes::sha256d;
-use io::{BufRead, Write};
-
-use crate::consensus::{self, encode, Decodable, Encodable, ReadExt};
-use crate::internal_macros::impl_consensus_encoding;
-use crate::p2p;
-use crate::p2p::address::Address;
-use crate::p2p::ServiceFlags;
-use crate::prelude::{Cow, String};
-
-// Some simple messages
-
-/// The `version` message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct VersionMessage {
-    /// The P2P network protocol version
-    pub version: u32,
-    /// A bitmask describing the services supported by this node
-    pub services: ServiceFlags,
-    /// The time at which the `version` message was sent
-    pub timestamp: i64,
-    /// The network address of the peer receiving the message
-    pub receiver: Address,
-    /// The network address of the peer sending the message
-    pub sender: Address,
-    /// A random nonce used to detect loops in the network
-    ///
-    /// The nonce can be used to detect situations when a node accidentally
-    /// connects to itself. Set it to a random value and, in case of incoming
-    /// connections, compare the value - same values mean self-connection.
-    ///
-    /// If your application uses P2P to only fetch the data and doesn't listen
-    /// you may just set it to 0.
-    pub nonce: u64,
-    /// A string describing the peer's software
-    pub user_agent: String,
-    /// The height of the maximum-work blockchain that the peer is aware of
-    pub start_height: i32,
-    /// Whether the receiving peer should relay messages to the sender; used
-    /// if the sender is bandwidth-limited and would like to support bloom
-    /// filtering. Defaults to false.
-    pub relay: bool,
-}
-
-impl VersionMessage {
-    /// Constructs a new `version` message with `relay` set to false
-    pub fn new(
-        services: ServiceFlags,
-        timestamp: i64,
-        receiver: Address,
-        sender: Address,
-        nonce: u64,
-        user_agent: String,
-        start_height: i32,
-    ) -> VersionMessage {
-        VersionMessage {
-            version: p2p::PROTOCOL_VERSION,
-            services,
-            timestamp,
-            receiver,
-            sender,
-            nonce,
-            user_agent,
-            start_height,
-            relay: false,
-        }
-    }
-}
-
-impl_consensus_encoding!(
-    VersionMessage,
-    version,
-    services,
-    timestamp,
-    receiver,
-    sender,
-    nonce,
-    user_agent,
-    start_height,
-    relay
-);
-
-/// message rejection reason as a code
-#[derive(PartialEq, Eq, Clone, Copy, Debug)]
-pub enum RejectReason {
-    /// malformed message
-    Malformed = 0x01,
-    /// invalid message
-    Invalid = 0x10,
-    /// obsolete message
-    Obsolete = 0x11,
-    /// duplicate message
-    Duplicate = 0x12,
-    /// nonstandard transaction
-    NonStandard = 0x40,
-    /// an output is below dust limit
-    Dust = 0x41,
-    /// insufficient fee
-    Fee = 0x42,
-    /// checkpoint
-    Checkpoint = 0x43,
-}
-
-impl Encodable for RejectReason {
-    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        w.write_all(&[*self as u8])?;
-        Ok(1)
-    }
-}
-
-impl Decodable for RejectReason {
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(match r.read_u8()? {
-            0x01 => RejectReason::Malformed,
-            0x10 => RejectReason::Invalid,
-            0x11 => RejectReason::Obsolete,
-            0x12 => RejectReason::Duplicate,
-            0x40 => RejectReason::NonStandard,
-            0x41 => RejectReason::Dust,
-            0x42 => RejectReason::Fee,
-            0x43 => RejectReason::Checkpoint,
-            _ => return Err(consensus::parse_failed_error("unknown reject code")),
-        })
-    }
-}
-
-/// Reject message might be sent by peers rejecting one of our messages
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct Reject {
-    /// message type rejected
-    pub message: Cow<'static, str>,
-    /// reason of rejection as code
-    pub ccode: RejectReason,
-    /// reason of rejection
-    pub reason: Cow<'static, str>,
-    /// reference to rejected item
-    pub hash: sha256d::Hash,
-}
-
-impl_consensus_encoding!(Reject, message, ccode, reason, hash);
-
-#[cfg(test)]
-mod tests {
-    use hex_lit::hex;
-
-    use super::*;
-    use crate::consensus::encode::{deserialize, serialize};
-
-    #[test]
-    fn version_message_test() {
-        // This message is from my satoshi node, morning of May 27 2014
-        let from_sat = hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001");
-
-        let decode: Result<VersionMessage, _> = deserialize(&from_sat);
-        assert!(decode.is_ok());
-        let real_decode = decode.unwrap();
-        assert_eq!(real_decode.version, 70002);
-        assert_eq!(real_decode.services, ServiceFlags::NETWORK);
-        assert_eq!(real_decode.timestamp, 1401217254);
-        // address decodes should be covered by Address tests
-        assert_eq!(real_decode.nonce, 16735069437859780935);
-        assert_eq!(real_decode.user_agent, "/Satoshi:0.9.99/".to_string());
-        assert_eq!(real_decode.start_height, 302892);
-        assert!(real_decode.relay);
-
-        assert_eq!(serialize(&real_decode), from_sat);
-    }
-
-    #[test]
-    fn reject_message_test() {
-        let reject_tx_conflict = hex!("027478121474786e2d6d656d706f6f6c2d636f6e666c69637405df54d3860b3c41806a3546ab48279300affacf4b88591b229141dcf2f47004");
-        let reject_tx_nonfinal = hex!("02747840096e6f6e2d66696e616c259bbe6c83db8bbdfca7ca303b19413dc245d9f2371b344ede5f8b1339a5460b");
-
-        let decode_result_conflict: Result<Reject, _> = deserialize(&reject_tx_conflict);
-        let decode_result_nonfinal: Result<Reject, _> = deserialize(&reject_tx_nonfinal);
-
-        assert!(decode_result_conflict.is_ok());
-        assert!(decode_result_nonfinal.is_ok());
-
-        let conflict = decode_result_conflict.unwrap();
-        assert_eq!("tx", conflict.message);
-        assert_eq!(RejectReason::Duplicate, conflict.ccode);
-        assert_eq!("txn-mempool-conflict", conflict.reason);
-        assert_eq!(
-            "0470f4f2dc4191221b59884bcffaaf00932748ab46356a80413c0b86d354df05"
-                .parse::<sha256d::Hash>()
-                .unwrap(),
-            conflict.hash
-        );
-
-        let nonfinal = decode_result_nonfinal.unwrap();
-        assert_eq!("tx", nonfinal.message);
-        assert_eq!(RejectReason::NonStandard, nonfinal.ccode);
-        assert_eq!("non-final", nonfinal.reason);
-        assert_eq!(
-            "0b46a539138b5fde4e341b37f2d945c23d41193b30caa7fcbd8bdb836cbe9b25"
-                .parse::<sha256d::Hash>()
-                .unwrap(),
-            nonfinal.hash
-        );
-
-        assert_eq!(serialize(&conflict), reject_tx_conflict);
-        assert_eq!(serialize(&nonfinal), reject_tx_nonfinal);
-    }
-}
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index 81216d0eae..0abb209877 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -10,11 +10,11 @@ use core::{cmp, fmt};
 
 use internals::impl_to_hex_from_lower_hex;
 use io::{BufRead, Write};
-use units::parse::{self, ParseIntError, PrefixedHexError, UnprefixedHexError};
+use units::parse_int::{self, ParseIntError, PrefixedHexError, UnprefixedHexError};
 
 use crate::block::{BlockHash, Header};
 use crate::consensus::encode::{self, Decodable, Encodable};
-use crate::internal_macros::define_extension_trait;
+use crate::internal_macros;
 use crate::network::Params;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -25,27 +25,27 @@ pub use primitives::CompactTarget;
 macro_rules! do_impl {
     ($ty:ident) => {
         impl $ty {
-            #[doc = "Creates `"]
+            #[doc = "Constructs `"]
             #[doc = stringify!($ty)]
             #[doc = "` from a prefixed hex string."]
             pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
                 Ok($ty(U256::from_hex(s)?))
             }
 
-            #[doc = "Creates `"]
+            #[doc = "Constructs `"]
             #[doc = stringify!($ty)]
             #[doc = "` from an unprefixed hex string."]
             pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
                 Ok($ty(U256::from_unprefixed_hex(s)?))
             }
 
-            #[doc = "Creates `"]
+            #[doc = "Constructs `"]
             #[doc = stringify!($ty)]
             #[doc = "` from a big-endian byte array."]
             #[inline]
             pub fn from_be_bytes(bytes: [u8; 32]) -> $ty { $ty(U256::from_be_bytes(bytes)) }
 
-            #[doc = "Creates `"]
+            #[doc = "Constructs `"]
             #[doc = stringify!($ty)]
             #[doc = "` from a little-endian byte array."]
             #[inline]
@@ -110,13 +110,13 @@ do_impl!(Work);
 impl_to_hex_from_lower_hex!(Work, |_| 64);
 
 impl Add for Work {
-    type Output = Work;
-    fn add(self, rhs: Self) -> Self { Work(self.0 + rhs.0) }
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self { Self(self.0 + rhs.0) }
 }
 
 impl Sub for Work {
-    type Output = Work;
-    fn sub(self, rhs: Self) -> Self { Work(self.0 - rhs.0) }
+    type Output = Self;
+    fn sub(self, rhs: Self) -> Self { Self(self.0 - rhs.0) }
 }
 
 /// A 256 bit integer representing target.
@@ -132,7 +132,7 @@ pub struct Target(U256);
 
 impl Target {
     /// When parsing nBits, Bitcoin Core converts a negative target threshold into a target of zero.
-    pub const ZERO: Target = Target(U256::ZERO);
+    pub const ZERO: Self = Self(U256::ZERO);
     /// The maximum possible target.
     ///
     /// This value is used to calculate difficulty, which is defined as how difficult the current
@@ -142,33 +142,33 @@ impl Target {
     /// ref: <https://en.bitcoin.it/wiki/Target>
     // In Bitcoind this is ~(u256)0 >> 32 stored as a floating-point type so it gets truncated, hence
     // the low 208 bits are all zero.
-    pub const MAX: Self = Target(U256(0xFFFF_u128 << (208 - 128), 0));
+    pub const MAX: Self = Self(U256(0xFFFF_u128 << (208 - 128), 0));
 
     /// The maximum **attainable** target value on mainnet.
     ///
     /// Not all target values are attainable because consensus code uses the compact format to
     /// represent targets (see [`CompactTarget`]).
-    pub const MAX_ATTAINABLE_MAINNET: Self = Target(U256(0xFFFF_u128 << (208 - 128), 0));
+    pub const MAX_ATTAINABLE_MAINNET: Self = Self(U256(0xFFFF_u128 << (208 - 128), 0));
 
     /// The proof of work limit on testnet.
     // Taken from Bitcoin Core but had lossy conversion to/from compact form.
     // https://github.com/bitcoin/bitcoin/blob/8105bce5b384c72cf08b25b7c5343622754e7337/src/kernel/chainparams.cpp#L208
-    pub const MAX_ATTAINABLE_TESTNET: Self = Target(U256(0xFFFF_u128 << (208 - 128), 0));
+    pub const MAX_ATTAINABLE_TESTNET: Self = Self(U256(0xFFFF_u128 << (208 - 128), 0));
 
     /// The proof of work limit on regtest.
     // Taken from Bitcoin Core but had lossy conversion to/from compact form.
     // https://github.com/bitcoin/bitcoin/blob/8105bce5b384c72cf08b25b7c5343622754e7337/src/kernel/chainparams.cpp#L411
-    pub const MAX_ATTAINABLE_REGTEST: Self = Target(U256(0x7FFF_FF00u128 << 96, 0));
+    pub const MAX_ATTAINABLE_REGTEST: Self = Self(U256(0x7FFF_FF00u128 << 96, 0));
 
     /// The proof of work limit on signet.
     // Taken from Bitcoin Core but had lossy conversion to/from compact form.
     // https://github.com/bitcoin/bitcoin/blob/8105bce5b384c72cf08b25b7c5343622754e7337/src/kernel/chainparams.cpp#L348
-    pub const MAX_ATTAINABLE_SIGNET: Self = Target(U256(0x0377_ae00 << 80, 0));
+    pub const MAX_ATTAINABLE_SIGNET: Self = Self(U256(0x0377_ae00 << 80, 0));
 
     /// Computes the [`Target`] value from a compact representation.
     ///
     /// ref: <https://developer.bitcoin.org/reference/block_chain.html#target-nbits>
-    pub fn from_compact(c: CompactTarget) -> Target {
+    pub fn from_compact(c: CompactTarget) -> Self {
         let bits = c.to_consensus();
         // This is a floating-point "compact" encoding originally used by
         // OpenSSL, which satoshi put into consensus code, so we're stuck
@@ -185,9 +185,9 @@ impl Target {
 
         // The mantissa is signed but may not be negative.
         if mant > 0x7F_FFFF {
-            Target::ZERO
+            Self::ZERO
         } else {
-            Target(U256::from(mant) << expt)
+            Self(U256::from(mant) << expt)
         }
     }
 
@@ -196,7 +196,7 @@ impl Target {
     /// The compact form is by definition lossy, this means that
     /// `t == Target::from_compact(t.to_compact_lossy())` does not always hold.
     pub fn to_compact_lossy(self) -> CompactTarget {
-        let mut size = (self.0.bits() + 7) / 8;
+        let mut size = self.0.bits().div_ceil(8);
         let mut compact = if size <= 3 {
             (self.0.low_u64() << (8 * (3 - size))) as u32
         } else {
@@ -332,18 +332,24 @@ impl Target {
 do_impl!(Target);
 impl_to_hex_from_lower_hex!(Target, |_| 64);
 
-define_extension_trait! {
+internal_macros::define_extension_trait! {
     /// Extension functionality for the [`CompactTarget`] type.
     pub trait CompactTargetExt impl for CompactTarget {
         /// Constructs a new `CompactTarget` from a prefixed hex string.
-        fn from_hex(s: &str) -> Result<CompactTarget, PrefixedHexError> {
-            let target = parse::hex_u32_prefixed(s)?;
+        fn from_hex(s: &str) -> Result<Self, PrefixedHexError>
+        where
+            Self: Sized
+        {
+            let target = parse_int::hex_u32_prefixed(s)?;
             Ok(Self::from_consensus(target))
         }
 
         /// Constructs a new `CompactTarget` from an unprefixed hex string.
-        fn from_unprefixed_hex(s: &str) -> Result<CompactTarget, UnprefixedHexError> {
-            let target = parse::hex_u32_unprefixed(s)?;
+        fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError>
+        where
+            Self: Sized
+        {
+            let target = parse_int::hex_u32_unprefixed(s)?;
             Ok(Self::from_consensus(target))
         }
 
@@ -375,7 +381,7 @@ define_extension_trait! {
             last: CompactTarget,
             timespan: i64,
             params: impl AsRef<Params>,
-        ) -> CompactTarget {
+        ) -> Self {
             let params = params.as_ref();
             if params.no_pow_retargeting {
                 return last;
@@ -419,7 +425,7 @@ define_extension_trait! {
             last_epoch_boundary: Header,
             current: Header,
             params: impl AsRef<Params>,
-        ) -> CompactTarget {
+        ) -> Self {
             let timespan = i64::from(current.time.to_u32()) - i64::from(last_epoch_boundary.time.to_u32());
             let bits = current.bits;
             CompactTarget::from_next_work_required(bits, timespan, params)
@@ -433,7 +439,7 @@ mod sealed {
 }
 
 impl From<CompactTarget> for Target {
-    fn from(c: CompactTarget) -> Self { Target::from_compact(c) }
+    fn from(c: CompactTarget) -> Self { Self::from_compact(c) }
 }
 
 impl Encodable for CompactTarget {
@@ -446,7 +452,7 @@ impl Encodable for CompactTarget {
 impl Decodable for CompactTarget {
     #[inline]
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        u32::consensus_decode(r).map(CompactTarget::from_consensus)
+        u32::consensus_decode(r).map(Self::from_consensus)
     }
 }
 
@@ -456,57 +462,57 @@ impl Decodable for CompactTarget {
 struct U256(u128, u128);
 
 impl U256 {
-    const MAX: U256 =
-        U256(0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff, 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
+    const MAX: Self =
+        Self(0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff, 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
 
-    const ZERO: U256 = U256(0, 0);
+    const ZERO: Self = Self(0, 0);
 
-    const ONE: U256 = U256(0, 1);
+    const ONE: Self = Self(0, 1);
 
     /// Constructs a new `U256` from a prefixed hex string.
     fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
-        let checked = parse::hex_remove_prefix(s)?;
-        Ok(U256::from_hex_internal(checked)?)
+        let checked = parse_int::hex_remove_prefix(s)?;
+        Ok(Self::from_hex_internal(checked)?)
     }
 
     /// Constructs a new `U256` from an unprefixed hex string.
     fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
-        let checked = parse::hex_check_unprefixed(s)?;
-        Ok(U256::from_hex_internal(checked)?)
+        let checked = parse_int::hex_check_unprefixed(s)?;
+        Ok(Self::from_hex_internal(checked)?)
     }
 
     // Caller to ensure `s` does not contain a prefix.
     fn from_hex_internal(s: &str) -> Result<Self, ParseIntError> {
         let (high, low) = if s.len() <= 32 {
-            let low = parse::hex_u128_unchecked(s)?;
+            let low = parse_int::hex_u128_unchecked(s)?;
             (0, low)
         } else {
             let high_len = s.len() - 32;
             let high_s = &s[..high_len];
             let low_s = &s[high_len..];
 
-            let high = parse::hex_u128_unchecked(high_s)?;
-            let low = parse::hex_u128_unchecked(low_s)?;
+            let high = parse_int::hex_u128_unchecked(high_s)?;
+            let low = parse_int::hex_u128_unchecked(low_s)?;
             (high, low)
         };
 
-        Ok(U256(high, low))
+        Ok(Self(high, low))
     }
 
     /// Constructs a new `U256` from a big-endian array of `u8`s.
-    fn from_be_bytes(a: [u8; 32]) -> U256 {
+    fn from_be_bytes(a: [u8; 32]) -> Self {
         let (high, low) = split_in_half(a);
         let big = u128::from_be_bytes(high);
         let little = u128::from_be_bytes(low);
-        U256(big, little)
+        Self(big, little)
     }
 
     /// Constructs a new `U256` from a little-endian array of `u8`s.
-    fn from_le_bytes(a: [u8; 32]) -> U256 {
+    fn from_le_bytes(a: [u8; 32]) -> Self {
         let (high, low) = split_in_half(a);
         let little = u128::from_le_bytes(high);
         let big = u128::from_le_bytes(low);
-        U256(big, little)
+        Self(big, little)
     }
 
     /// Converts `U256` to a big-endian array of `u8`s.
@@ -530,19 +536,19 @@ impl U256 {
     /// 2**256 / (x + 1) == ~x / (x + 1) + 1
     ///
     /// (Equation shamelessly stolen from bitcoind)
-    fn inverse(&self) -> U256 {
+    fn inverse(&self) -> Self {
         // We should never have a target/work of zero so this doesn't matter
         // that much but we define the inverse of 0 as max.
         if self.is_zero() {
-            return U256::MAX;
+            return Self::MAX;
         }
         // We define the inverse of 1 as max.
         if self.is_one() {
-            return U256::MAX;
+            return Self::MAX;
         }
         // We define the inverse of max as 1.
         if self.is_max() {
-            return U256::ONE;
+            return Self::ONE;
         }
 
         let ret = !*self / self.wrapping_inc();
@@ -567,7 +573,7 @@ impl U256 {
     /// Returns this `U256` as a `u128` saturating to `u128::MAX` if `self` is too big.
     // Mutagen gives false positive because >= and > both return u128::MAX
     fn saturating_to_u128(&self) -> u128 {
-        if *self > U256::from(u128::MAX) {
+        if *self > Self::from(u128::MAX) {
             u128::MAX
         } else {
             self.low_u128()
@@ -589,7 +595,7 @@ impl U256 {
     ///
     /// The multiplication result along with a boolean indicating whether an arithmetic overflow
     /// occurred. If an overflow occurred then the wrapped value is returned.
-    fn mul_u64(self, rhs: u64) -> (U256, bool) {
+    fn mul_u64(self, rhs: u64) -> (Self, bool) {
         let mut carry: u128 = 0;
         let mut split_le =
             [self.1 as u64, (self.1 >> 64) as u64, self.0 as u64, (self.0 >> 64) as u64];
@@ -629,7 +635,7 @@ impl U256 {
 
         // Early return in case we are dividing by a larger number than us
         if my_bits < your_bits {
-            return (U256::ZERO, sub_copy);
+            return (Self::ZERO, sub_copy);
         }
 
         // Bitwise long division
@@ -647,7 +653,7 @@ impl U256 {
             shift -= 1;
         }
 
-        (U256(ret[0], ret[1]), sub_copy)
+        (Self(ret[0], ret[1]), sub_copy)
     }
 
     /// Calculates `self` + `rhs`
@@ -656,7 +662,7 @@ impl U256 {
     /// overflow would occur. If an overflow would have occurred then the wrapped value is returned.
     #[must_use = "this returns the result of the operation, without modifying the original"]
     fn overflowing_add(self, rhs: Self) -> (Self, bool) {
-        let mut ret = U256::ZERO;
+        let mut ret = Self::ZERO;
         let mut ret_overflow = false;
 
         let (high, overflow) = self.0.overflowing_add(rhs.0);
@@ -692,7 +698,7 @@ impl U256 {
     /// overflow would have occurred then the wrapped value is returned.
     #[must_use = "this returns the result of the operation, without modifying the original"]
     fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
-        let mut ret = U256::ZERO;
+        let mut ret = Self::ZERO;
         let mut ret_overflow = false;
 
         for i in 0..3 {
@@ -738,8 +744,8 @@ impl U256 {
 
     /// Returns `self` incremented by 1 wrapping around at the boundary of the type.
     #[must_use = "this returns the result of the increment, without modifying the original"]
-    fn wrapping_inc(&self) -> U256 {
-        let mut ret = U256::ZERO;
+    fn wrapping_inc(&self) -> Self {
+        let mut ret = Self::ZERO;
 
         ret.1 = self.1.wrapping_add(1);
         if ret.1 == 0 {
@@ -760,7 +766,7 @@ impl U256 {
     fn wrapping_shl(self, rhs: u32) -> Self {
         let shift = rhs & 0x000000ff;
 
-        let mut ret = U256::ZERO;
+        let mut ret = Self::ZERO;
         let word_shift = shift >= 128;
         let bit_shift = shift % 128;
 
@@ -786,7 +792,7 @@ impl U256 {
     fn wrapping_shr(self, rhs: u32) -> Self {
         let shift = rhs & 0x000000ff;
 
-        let mut ret = U256::ZERO;
+        let mut ret = Self::ZERO;
         let word_shift = shift >= 128;
         let bit_shift = shift % 128;
 
@@ -824,7 +830,7 @@ impl U256 {
         f.pad_integral(true, "", s)
     }
 
-    /// Convert self to f64.
+    /// Converts self to f64.
     #[inline]
     fn to_f64(self) -> f64 {
         // Reference: https://blog.m-ou.se/floats/
@@ -862,7 +868,7 @@ impl U256 {
 }
 
 impl<T: Into<u128>> From<T> for U256 {
-    fn from(x: T) -> Self { U256(0, x.into()) }
+    fn from(x: T) -> Self { Self(0, x.into()) }
 }
 
 impl Add for U256 {
@@ -905,17 +911,17 @@ impl Rem for U256 {
 impl Not for U256 {
     type Output = Self;
 
-    fn not(self) -> Self { U256(!self.0, !self.1) }
+    fn not(self) -> Self { Self(!self.0, !self.1) }
 }
 
 impl Shl<u32> for U256 {
     type Output = Self;
-    fn shl(self, shift: u32) -> U256 { self.wrapping_shl(shift) }
+    fn shl(self, shift: u32) -> Self { self.wrapping_shl(shift) }
 }
 
 impl Shr<u32> for U256 {
     type Output = Self;
-    fn shr(self, shift: u32) -> U256 { self.wrapping_shr(shift) }
+    fn shr(self, shift: u32) -> Self { self.wrapping_shr(shift) }
 }
 
 impl fmt::Display for U256 {
@@ -1077,7 +1083,9 @@ pub mod test_utils {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pow::test_utils::{u128_to_work, u32_to_target, u64_to_target};
+    #[cfg(feature = "std")]
+    use crate::pow::test_utils::u128_to_work;
+    use crate::pow::test_utils::{u32_to_target, u64_to_target};
     use crate::BlockTime;
 
     impl U256 {
@@ -1092,7 +1100,7 @@ mod tests {
 
         /// Constructs a new U256 from a big-endian array of u64's
         fn from_array(a: [u64; 4]) -> Self {
-            let mut ret = U256::ZERO;
+            let mut ret = Self::ZERO;
             ret.0 = ((a[0] as u128) << 64) ^ (a[1] as u128);
             ret.1 = ((a[2] as u128) << 64) ^ (a[3] as u128);
             ret
diff --git a/bitcoin/src/psbt/error.rs b/bitcoin/src/psbt/error.rs
index 58338ab691..3a62df06e7 100644
--- a/bitcoin/src/psbt/error.rs
+++ b/bitcoin/src/psbt/error.rs
@@ -9,7 +9,7 @@ use crate::bip32::Xpub;
 use crate::consensus::encode;
 use crate::prelude::Box;
 use crate::psbt::raw;
-use crate::transaction::Transaction;
+use crate::{ecdsa, key, taproot, OutPoint, Transaction, Txid};
 
 /// Enum for marking psbt hash error.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
@@ -80,16 +80,26 @@ pub enum Error {
     NegativeFee,
     /// Integer overflow in fee calculation
     FeeOverflow,
+    /// Non-witness UTXO (which is a complete transaction) has `Txid` that
+    /// does not match the transaction input.
+    IncorrectNonWitnessUtxo {
+        /// The index of the input in question.
+        index: usize,
+        /// The outpoint of the input, as it appears in the unsigned transaction.
+        input_outpoint: OutPoint,
+        /// The [`Txid`] of the non-witness UTXO.
+        non_witness_utxo_txid: Txid,
+    },
     /// Parsing error indicating invalid public keys
-    InvalidPublicKey(crate::crypto::key::FromSliceError),
+    InvalidPublicKey(key::FromSliceError),
     /// Parsing error indicating invalid secp256k1 public keys
     InvalidSecp256k1PublicKey(secp256k1::Error),
     /// Parsing error indicating invalid xonly public keys
     InvalidXOnlyPublicKey,
     /// Parsing error indicating invalid ECDSA signatures
-    InvalidEcdsaSignature(crate::crypto::ecdsa::DecodeError),
+    InvalidEcdsaSignature(ecdsa::DecodeError),
     /// Parsing error indicating invalid Taproot signatures
-    InvalidTaprootSignature(crate::crypto::taproot::SigFromSliceError),
+    InvalidTaprootSignature(taproot::SigFromSliceError),
     /// Parsing error indicating invalid control block
     InvalidControlBlock,
     /// Parsing error indicating invalid leaf version
@@ -97,7 +107,7 @@ pub enum Error {
     /// Parsing error indicating a Taproot error
     Taproot(&'static str),
     /// Taproot tree deserialization error
-    TapTree(crate::taproot::IncompleteBuilderError),
+    TapTree(taproot::IncompleteBuilderError),
     /// Error related to an xpub key
     XPubKey(&'static str),
     /// Error related to PSBT version
@@ -114,60 +124,68 @@ impl From<Infallible> for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use Error::*;
-
-        match *self {
-            InvalidMagic => f.write_str("invalid magic"),
-            MissingUtxo => f.write_str("UTXO information is not present in PSBT"),
-            InvalidSeparator => f.write_str("invalid separator"),
-            PsbtUtxoOutOfbounds =>
+        match self {
+            Self::InvalidMagic => f.write_str("invalid magic"),
+            Self::MissingUtxo => f.write_str("UTXO information is not present in PSBT"),
+            Self::InvalidSeparator => f.write_str("invalid separator"),
+            Self::PsbtUtxoOutOfbounds =>
                 f.write_str("output index is out of bounds of non witness script output array"),
-            InvalidKey(ref rkey) => write!(f, "invalid key: {}", rkey),
-            InvalidProprietaryKey =>
+            Self::InvalidKey(ref rkey) => write!(f, "invalid key: {}", rkey),
+            Self::InvalidProprietaryKey =>
                 write!(f, "non-proprietary key type found when proprietary key was expected"),
-            DuplicateKey(ref rkey) => write!(f, "duplicate key: {}", rkey),
-            UnsignedTxHasScriptSigs => f.write_str("the unsigned transaction has script sigs"),
-            UnsignedTxHasScriptWitnesses =>
+            Self::DuplicateKey(ref rkey) => write!(f, "duplicate key: {}", rkey),
+            Self::UnsignedTxHasScriptSigs =>
+                f.write_str("the unsigned transaction has script sigs"),
+            Self::UnsignedTxHasScriptWitnesses =>
                 f.write_str("the unsigned transaction has script witnesses"),
-            MustHaveUnsignedTx =>
+            Self::MustHaveUnsignedTx =>
                 f.write_str("partially signed transactions must have an unsigned transaction"),
-            NoMorePairs => f.write_str("no more key-value pairs for this psbt map"),
-            UnexpectedUnsignedTx { expected: ref e, actual: ref a } => write!(
+            Self::NoMorePairs => f.write_str("no more key-value pairs for this psbt map"),
+            Self::UnexpectedUnsignedTx { expected: ref e, actual: ref a } => write!(
                 f,
                 "different unsigned transaction: expected {}, actual {}",
                 e.compute_txid(),
                 a.compute_txid()
             ),
-            NonStandardSighashType(ref sht) => write!(f, "non-standard sighash type: {}", sht),
-            InvalidHash(ref e) => write_err!(f, "invalid hash when parsing slice"; e),
-            InvalidPreimageHashPair { ref preimage, ref hash, ref hash_type } => {
+            Self::NonStandardSighashType(ref sht) =>
+                write!(f, "non-standard sighash type: {}", sht),
+            Self::InvalidHash(ref e) => write_err!(f, "invalid hash when parsing slice"; e),
+            Self::InvalidPreimageHashPair { ref preimage, ref hash, ref hash_type } => {
                 // directly using debug forms of psbthash enums
                 write!(f, "Preimage {:?} does not match {:?} hash {:?}", preimage, hash_type, hash)
             }
-            CombineInconsistentKeySources(ref s) => {
+            Self::CombineInconsistentKeySources(ref s) => {
                 write!(f, "combine conflict: {}", s)
             }
-            ConsensusEncoding(ref e) => write_err!(f, "bitcoin consensus encoding error"; e),
-            ConsensusDeserialize(ref e) =>
-                write_err!(f, "bitcoin consensus deserializaton error"; e),
-            ConsensusParse(ref e) =>
+            Self::ConsensusEncoding(ref e) => write_err!(f, "bitcoin consensus encoding error"; e),
+            Self::ConsensusDeserialize(ref e) =>
+                write_err!(f, "bitcoin consensus deserialization error"; e),
+            Self::ConsensusParse(ref e) =>
                 write_err!(f, "error parsing bitcoin consensus encoded object"; e),
-            NegativeFee => f.write_str("PSBT has a negative fee which is not allowed"),
-            FeeOverflow => f.write_str("integer overflow in fee calculation"),
-            InvalidPublicKey(ref e) => write_err!(f, "invalid public key"; e),
-            InvalidSecp256k1PublicKey(ref e) => write_err!(f, "invalid secp256k1 public key"; e),
-            InvalidXOnlyPublicKey => f.write_str("invalid xonly public key"),
-            InvalidEcdsaSignature(ref e) => write_err!(f, "invalid ECDSA signature"; e),
-            InvalidTaprootSignature(ref e) => write_err!(f, "invalid Taproot signature"; e),
-            InvalidControlBlock => f.write_str("invalid control block"),
-            InvalidLeafVersion => f.write_str("invalid leaf version"),
-            Taproot(s) => write!(f, "Taproot error -  {}", s),
-            TapTree(ref e) => write_err!(f, "Taproot tree error"; e),
-            XPubKey(s) => write!(f, "xpub key error -  {}", s),
-            Version(s) => write!(f, "version error {}", s),
-            PartialDataConsumption =>
+            Self::NegativeFee => f.write_str("PSBT has a negative fee which is not allowed"),
+            Self::FeeOverflow => f.write_str("integer overflow in fee calculation"),
+            Self::IncorrectNonWitnessUtxo { index, input_outpoint, non_witness_utxo_txid } => {
+                write!(
+                    f,
+                    "non-witness utxo txid is {}, which does not match input {}'s outpoint {}",
+                    non_witness_utxo_txid, index, input_outpoint
+                )
+            }
+            Self::InvalidPublicKey(ref e) => write_err!(f, "invalid public key"; e),
+            Self::InvalidSecp256k1PublicKey(ref e) =>
+                write_err!(f, "invalid secp256k1 public key"; e),
+            Self::InvalidXOnlyPublicKey => f.write_str("invalid xonly public key"),
+            Self::InvalidEcdsaSignature(ref e) => write_err!(f, "invalid ECDSA signature"; e),
+            Self::InvalidTaprootSignature(ref e) => write_err!(f, "invalid Taproot signature"; e),
+            Self::InvalidControlBlock => f.write_str("invalid control block"),
+            Self::InvalidLeafVersion => f.write_str("invalid leaf version"),
+            Self::Taproot(s) => write!(f, "Taproot error -  {}", s),
+            Self::TapTree(ref e) => write_err!(f, "Taproot tree error"; e),
+            Self::XPubKey(s) => write!(f, "xpub key error -  {}", s),
+            Self::Version(s) => write!(f, "version error {}", s),
+            Self::PartialDataConsumption =>
                 f.write_str("data not consumed entirely when explicitly deserializing"),
-            Io(ref e) => write_err!(f, "I/O error"; e),
+            Self::Io(ref e) => write_err!(f, "I/O error"; e),
         }
     }
 }
@@ -175,63 +193,62 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use Error::*;
-
-        match *self {
-            InvalidHash(ref e) => Some(e),
-            ConsensusEncoding(ref e) => Some(e),
-            ConsensusDeserialize(ref e) => Some(e),
-            ConsensusParse(ref e) => Some(e),
-            Io(ref e) => Some(e),
-            InvalidMagic
-            | MissingUtxo
-            | InvalidSeparator
-            | PsbtUtxoOutOfbounds
-            | InvalidKey(_)
-            | InvalidProprietaryKey
-            | DuplicateKey(_)
-            | UnsignedTxHasScriptSigs
-            | UnsignedTxHasScriptWitnesses
-            | MustHaveUnsignedTx
-            | NoMorePairs
-            | UnexpectedUnsignedTx { .. }
-            | NonStandardSighashType(_)
-            | InvalidPreimageHashPair { .. }
-            | CombineInconsistentKeySources(_)
-            | NegativeFee
-            | FeeOverflow
-            | InvalidPublicKey(_)
-            | InvalidSecp256k1PublicKey(_)
-            | InvalidXOnlyPublicKey
-            | InvalidEcdsaSignature(_)
-            | InvalidTaprootSignature(_)
-            | InvalidControlBlock
-            | InvalidLeafVersion
-            | Taproot(_)
-            | TapTree(_)
-            | XPubKey(_)
-            | Version(_)
-            | PartialDataConsumption => None,
+        match self {
+            Self::InvalidHash(ref e) => Some(e),
+            Self::ConsensusEncoding(ref e) => Some(e),
+            Self::ConsensusDeserialize(ref e) => Some(e),
+            Self::ConsensusParse(ref e) => Some(e),
+            Self::Io(ref e) => Some(e),
+            Self::InvalidMagic
+            | Self::MissingUtxo
+            | Self::InvalidSeparator
+            | Self::PsbtUtxoOutOfbounds
+            | Self::InvalidKey(_)
+            | Self::InvalidProprietaryKey
+            | Self::DuplicateKey(_)
+            | Self::UnsignedTxHasScriptSigs
+            | Self::UnsignedTxHasScriptWitnesses
+            | Self::MustHaveUnsignedTx
+            | Self::NoMorePairs
+            | Self::UnexpectedUnsignedTx { .. }
+            | Self::NonStandardSighashType(_)
+            | Self::InvalidPreimageHashPair { .. }
+            | Self::CombineInconsistentKeySources(_)
+            | Self::NegativeFee
+            | Self::FeeOverflow
+            | Self::IncorrectNonWitnessUtxo { .. }
+            | Self::InvalidPublicKey(_)
+            | Self::InvalidSecp256k1PublicKey(_)
+            | Self::InvalidXOnlyPublicKey
+            | Self::InvalidEcdsaSignature(_)
+            | Self::InvalidTaprootSignature(_)
+            | Self::InvalidControlBlock
+            | Self::InvalidLeafVersion
+            | Self::Taproot(_)
+            | Self::TapTree(_)
+            | Self::XPubKey(_)
+            | Self::Version(_)
+            | Self::PartialDataConsumption => None,
         }
     }
 }
 
 impl From<core::array::TryFromSliceError> for Error {
-    fn from(e: core::array::TryFromSliceError) -> Error { Error::InvalidHash(e) }
+    fn from(e: core::array::TryFromSliceError) -> Self { Self::InvalidHash(e) }
 }
 
 impl From<encode::Error> for Error {
-    fn from(e: encode::Error) -> Self { Error::ConsensusEncoding(e) }
+    fn from(e: encode::Error) -> Self { Self::ConsensusEncoding(e) }
 }
 
 impl From<encode::DeserializeError> for Error {
-    fn from(e: encode::DeserializeError) -> Self { Error::ConsensusDeserialize(e) }
+    fn from(e: encode::DeserializeError) -> Self { Self::ConsensusDeserialize(e) }
 }
 
 impl From<encode::ParseError> for Error {
-    fn from(e: encode::ParseError) -> Self { Error::ConsensusParse(e) }
+    fn from(e: encode::ParseError) -> Self { Self::ConsensusParse(e) }
 }
 
 impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Self { Error::Io(e) }
+    fn from(e: io::Error) -> Self { Self::Io(e) }
 }
diff --git a/bitcoin/src/psbt/map/global.rs b/bitcoin/src/psbt/map/global.rs
index 866c77d18e..6a24c13111 100644
--- a/bitcoin/src/psbt/map/global.rs
+++ b/bitcoin/src/psbt/map/global.rs
@@ -31,8 +31,8 @@ impl Map for Psbt {
                 // without witnesses.
                 let mut ret = Vec::new();
                 ret.extend(encode::serialize(&self.unsigned_tx.version));
-                ret.extend(encode::serialize(&self.unsigned_tx.input));
-                ret.extend(encode::serialize(&self.unsigned_tx.output));
+                ret.extend(encode::serialize(&self.unsigned_tx.inputs));
+                ret.extend(encode::serialize(&self.unsigned_tx.outputs));
                 ret.extend(encode::serialize(&self.unsigned_tx.lock_time));
                 ret
             },
@@ -96,8 +96,8 @@ impl Psbt {
                                     // properly.
                                     tx = Some(Transaction {
                                         version: Decodable::consensus_decode(&mut decoder)?,
-                                        input: Decodable::consensus_decode(&mut decoder)?,
-                                        output: Decodable::consensus_decode(&mut decoder)?,
+                                        inputs: Decodable::consensus_decode(&mut decoder)?,
+                                        outputs: Decodable::consensus_decode(&mut decoder)?,
                                         lock_time: Decodable::consensus_decode(&mut decoder)?,
                                     });
 
@@ -135,7 +135,7 @@ impl Psbt {
                                     path.push(ChildNumber::from(index))
                                 }
                                 let derivation = DerivationPath::from(path);
-                                // Keys, according to BIP-174, must be unique
+                                // Keys, according to BIP-0174, must be unique
                                 if xpub_map
                                     .insert(xpub, (Fingerprint::from(fingerprint), derivation))
                                     .is_some()
@@ -161,7 +161,7 @@ impl Psbt {
                                         ));
                                     }
                                     version = Some(Decodable::consensus_decode(&mut decoder)?);
-                                    // We only understand version 0 PSBTs. According to BIP-174 we
+                                    // We only understand version 0 PSBTs. According to BIP-0174 we
                                     // should throw an error if we see anything other than version 0.
                                     if version != Some(0) {
                                         return Err(Error::Version(
@@ -199,7 +199,7 @@ impl Psbt {
         }
 
         if let Some(tx) = tx {
-            Ok(Psbt {
+            Ok(Self {
                 unsigned_tx: tx,
                 version: version.unwrap_or(0),
                 xpub: xpub_map,
diff --git a/bitcoin/src/psbt/map/input.rs b/bitcoin/src/psbt/map/input.rs
index d33be651b5..3d19185e78 100644
--- a/bitcoin/src/psbt/map/input.rs
+++ b/bitcoin/src/psbt/map/input.rs
@@ -12,7 +12,7 @@ use crate::prelude::{btree_map, BTreeMap, Borrow, Box, ToOwned, Vec};
 use crate::psbt::map::Map;
 use crate::psbt::serialize::Deserialize;
 use crate::psbt::{error, raw, Error};
-use crate::script::ScriptBuf;
+use crate::script::{RedeemScriptBuf, ScriptSigBuf, TapScriptBuf, WitnessScriptBuf};
 use crate::sighash::{
     EcdsaSighashType, InvalidSighashTypeError, NonStandardSighashTypeError, SighashTypeParseError,
     TapSighashType,
@@ -33,7 +33,7 @@ const PSBT_IN_SIGHASH_TYPE: u64 = 0x03;
 const PSBT_IN_REDEEM_SCRIPT: u64 = 0x04;
 /// Type: Witness Script PSBT_IN_WITNESS_SCRIPT = 0x05
 const PSBT_IN_WITNESS_SCRIPT: u64 = 0x05;
-/// Type: BIP 32 Derivation Path PSBT_IN_BIP32_DERIVATION = 0x06
+/// Type: BIP-0032 Derivation Path PSBT_IN_BIP32_DERIVATION = 0x06
 const PSBT_IN_BIP32_DERIVATION: u64 = 0x06;
 /// Type: Finalized scriptSig PSBT_IN_FINAL_SCRIPTSIG = 0x07
 const PSBT_IN_FINAL_SCRIPTSIG: u64 = 0x07;
@@ -51,21 +51,22 @@ const PSBT_IN_HASH256: u64 = 0x0d;
 const PSBT_IN_TAP_KEY_SIG: u64 = 0x13;
 /// Type: Taproot Signature in Script Spend PSBT_IN_TAP_SCRIPT_SIG = 0x14
 const PSBT_IN_TAP_SCRIPT_SIG: u64 = 0x14;
-/// Type: Taproot Leaf Script PSBT_IN_TAP_LEAF_SCRIPT = 0x14
+/// Type: Taproot Leaf Script PSBT_IN_TAP_LEAF_SCRIPT = 0x15
 const PSBT_IN_TAP_LEAF_SCRIPT: u64 = 0x15;
-/// Type: Taproot Key BIP 32 Derivation Path PSBT_IN_TAP_BIP32_DERIVATION = 0x16
+/// Type: Taproot Key BIP-0032 Derivation Path PSBT_IN_TAP_BIP32_DERIVATION = 0x16
 const PSBT_IN_TAP_BIP32_DERIVATION: u64 = 0x16;
 /// Type: Taproot Internal Key PSBT_IN_TAP_INTERNAL_KEY = 0x17
 const PSBT_IN_TAP_INTERNAL_KEY: u64 = 0x17;
 /// Type: Taproot Merkle Root PSBT_IN_TAP_MERKLE_ROOT = 0x18
 const PSBT_IN_TAP_MERKLE_ROOT: u64 = 0x18;
+/// Type: MuSig2 Public Keys Participating in Aggregate Input PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS = 0x1a
+const PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS: u64 = 0x1a;
 /// Type: Proprietary Use Type PSBT_IN_PROPRIETARY = 0xFC
 const PSBT_IN_PROPRIETARY: u64 = 0xFC;
 
 /// A key-value map for an input of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
     /// `Option::Some` for inputs which spend non-SegWit outputs or
@@ -82,51 +83,43 @@ pub struct Input {
     /// must use the sighash type.
     pub sighash_type: Option<PsbtSighashType>,
     /// The redeem script for this input.
-    pub redeem_script: Option<ScriptBuf>,
+    pub redeem_script: Option<RedeemScriptBuf>,
     /// The witness script for this input.
-    pub witness_script: Option<ScriptBuf>,
+    pub witness_script: Option<WitnessScriptBuf>,
     /// A map from public keys needed to sign this input to their corresponding
     /// master key fingerprints and derivation paths.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub bip32_derivation: BTreeMap<secp256k1::PublicKey, KeySource>,
     /// The finalized, fully-constructed scriptSig with signatures and any other
     /// scripts necessary for this input to pass validation.
-    pub final_script_sig: Option<ScriptBuf>,
+    pub final_script_sig: Option<ScriptSigBuf>,
     /// The finalized, fully-constructed scriptWitness with signatures and any
     /// other scripts necessary for this input to pass validation.
     pub final_script_witness: Option<Witness>,
     /// RIPEMD160 hash to preimage map.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_byte_values"))]
     pub ripemd160_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
     /// SHA256 hash to preimage map.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_byte_values"))]
     pub sha256_preimages: BTreeMap<sha256::Hash, Vec<u8>>,
     /// HASH160 hash to preimage map.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_byte_values"))]
     pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
     /// HASH256 hash to preimage map.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_byte_values"))]
     pub hash256_preimages: BTreeMap<sha256d::Hash, Vec<u8>>,
     /// Serialized Taproot signature with sighash type for key spend.
     pub tap_key_sig: Option<taproot::Signature>,
     /// Map of `<xonlypubkey>|<leafhash>` with signature.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_script_sigs: BTreeMap<(XOnlyPublicKey, TapLeafHash), taproot::Signature>,
     /// Map of Control blocks to Script version pair.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
-    pub tap_scripts: BTreeMap<ControlBlock, (ScriptBuf, LeafVersion)>,
+    pub tap_scripts: BTreeMap<ControlBlock, (TapScriptBuf, LeafVersion)>,
     /// Map of tap root x only keys to origin info and leaf hashes contained in it.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
     /// Taproot Internal key.
     pub tap_internal_key: Option<XOnlyPublicKey>,
     /// Taproot Merkle root.
     pub tap_merkle_root: Option<TapNodeHash>,
+    /// Mapping from MuSig2 aggregate keys to the participant keys from which they were aggregated.
+    pub musig2_participant_pubkeys: BTreeMap<secp256k1::PublicKey, Vec<secp256k1::PublicKey>>,
     /// Proprietary key-value pairs for this input.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown key-value pairs for this input.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
 
@@ -147,7 +140,6 @@ pub struct Input {
 /// let _tap_sighash_all: PsbtSighashType = TapSighashType::All.into();
 /// ```
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PsbtSighashType {
     pub(in crate::psbt) inner: u32,
 }
@@ -177,22 +169,18 @@ impl FromStr for PsbtSighashType {
 
         // We accept non-standard sighash values.
         if let Ok(inner) = u32::from_str_radix(s.trim_start_matches("0x"), 16) {
-            return Ok(PsbtSighashType { inner });
+            return Ok(Self { inner });
         }
 
         Err(SighashTypeParseError { unrecognized: s.to_owned() })
     }
 }
 impl From<EcdsaSighashType> for PsbtSighashType {
-    fn from(ecdsa_hash_ty: EcdsaSighashType) -> Self {
-        PsbtSighashType { inner: ecdsa_hash_ty as u32 }
-    }
+    fn from(ecdsa_hash_ty: EcdsaSighashType) -> Self { Self { inner: ecdsa_hash_ty as u32 } }
 }
 
 impl From<TapSighashType> for PsbtSighashType {
-    fn from(taproot_hash_ty: TapSighashType) -> Self {
-        PsbtSighashType { inner: taproot_hash_ty as u32 }
-    }
+    fn from(taproot_hash_ty: TapSighashType) -> Self { Self { inner: taproot_hash_ty as u32 } }
 }
 
 impl PsbtSighashType {
@@ -210,7 +198,7 @@ impl PsbtSighashType {
     /// let _ecdsa_sighash_anyone_can_pay: PsbtSighashType = EcdsaSighashType::AllPlusAnyoneCanPay.into();
     /// let _tap_sighash_anyone_can_pay: PsbtSighashType = TapSighashType::AllPlusAnyoneCanPay.into();
     /// ```
-    pub const ALL: PsbtSighashType = PsbtSighashType { inner: 0x01 };
+    pub const ALL: Self = Self { inner: 0x01 };
 
     /// Returns the [`EcdsaSighashType`] if the [`PsbtSighashType`] can be
     /// converted to one.
@@ -232,7 +220,7 @@ impl PsbtSighashType {
     ///
     /// Allows construction of a non-standard or non-valid sighash flag
     /// ([`EcdsaSighashType`], [`TapSighashType`] respectively).
-    pub fn from_u32(n: u32) -> PsbtSighashType { PsbtSighashType { inner: n } }
+    pub fn from_u32(n: u32) -> Self { Self { inner: n } }
 
     /// Converts [`PsbtSighashType`] to a raw `u32` sighash flag.
     ///
@@ -258,7 +246,7 @@ impl Input {
     ///
     /// # Errors
     ///
-    /// If the `sighash_type` field is set to a invalid Taproot sighash value.
+    /// If the `sighash_type` field is set to an invalid Taproot sighash value.
     pub fn taproot_hash_ty(&self) -> Result<TapSighashType, InvalidSighashTypeError> {
         self.sighash_type
             .map(|sighash_type| sighash_type.taproot_hash_ty())
@@ -291,12 +279,12 @@ impl Input {
             }
             PSBT_IN_REDEEM_SCRIPT => {
                 impl_psbt_insert_pair! {
-                    self.redeem_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                    self.redeem_script <= <raw_key: _>|<raw_value: RedeemScriptBuf>
                 }
             }
             PSBT_IN_WITNESS_SCRIPT => {
                 impl_psbt_insert_pair! {
-                    self.witness_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                    self.witness_script <= <raw_key: _>|<raw_value: WitnessScriptBuf>
                 }
             }
             PSBT_IN_BIP32_DERIVATION => {
@@ -306,7 +294,7 @@ impl Input {
             }
             PSBT_IN_FINAL_SCRIPTSIG => {
                 impl_psbt_insert_pair! {
-                    self.final_script_sig <= <raw_key: _>|<raw_value: ScriptBuf>
+                    self.final_script_sig <= <raw_key: _>|<raw_value: ScriptSigBuf>
                 }
             }
             PSBT_IN_FINAL_SCRIPTWITNESS => {
@@ -346,7 +334,7 @@ impl Input {
             }
             PSBT_IN_TAP_LEAF_SCRIPT => {
                 impl_psbt_insert_pair! {
-                    self.tap_scripts <= <raw_key: ControlBlock>|< raw_value: (ScriptBuf, LeafVersion)>
+                    self.tap_scripts <= <raw_key: ControlBlock>|< raw_value: (TapScriptBuf, LeafVersion)>
                 }
             }
             PSBT_IN_TAP_BIP32_DERIVATION => {
@@ -364,6 +352,11 @@ impl Input {
                     self.tap_merkle_root <= <raw_key: _>|< raw_value: TapNodeHash>
                 }
             }
+            PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS => {
+                impl_psbt_insert_pair! {
+                    self.musig2_participant_pubkeys <= <raw_key: secp256k1::PublicKey>|< raw_value: Vec<secp256k1::PublicKey> >
+                }
+            }
             PSBT_IN_PROPRIETARY => {
                 let key = raw::ProprietaryKey::try_from(raw_key.clone())?;
                 match self.proprietary.entry(key) {
@@ -402,6 +395,7 @@ impl Input {
         self.tap_script_sigs.extend(other.tap_script_sigs);
         self.tap_scripts.extend(other.tap_scripts);
         self.tap_key_origins.extend(other.tap_key_origins);
+        self.musig2_participant_pubkeys.extend(other.musig2_participant_pubkeys);
         self.proprietary.extend(other.proprietary);
         self.unknown.extend(other.unknown);
 
@@ -494,6 +488,11 @@ impl Map for Input {
         impl_psbt_get_pair! {
             rv.push(self.tap_merkle_root, PSBT_IN_TAP_MERKLE_ROOT)
         }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.musig2_participant_pubkeys, PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS)
+        }
+
         for (key, value) in self.proprietary.iter() {
             rv.push(raw::Pair { key: key.to_key(), value: value.clone() });
         }
diff --git a/bitcoin/src/psbt/map/mod.rs b/bitcoin/src/psbt/map/mod.rs
index b086a3e9b6..58c28699a3 100644
--- a/bitcoin/src/psbt/map/mod.rs
+++ b/bitcoin/src/psbt/map/mod.rs
@@ -20,7 +20,7 @@ pub(super) trait Map {
     /// Attempt to get all key-value pairs.
     fn get_pairs(&self) -> Vec<raw::Pair>;
 
-    /// Serialize Psbt binary map data according to BIP-174 specification.
+    /// Serialize Psbt binary map data according to BIP-0174 specification.
     ///
     /// <map> := <keypair>* 0x00
     ///
diff --git a/bitcoin/src/psbt/map/output.rs b/bitcoin/src/psbt/map/output.rs
index 22e28abc63..d48fc337df 100644
--- a/bitcoin/src/psbt/map/output.rs
+++ b/bitcoin/src/psbt/map/output.rs
@@ -5,49 +5,48 @@ use crate::crypto::key::XOnlyPublicKey;
 use crate::prelude::{btree_map, BTreeMap, Vec};
 use crate::psbt::map::Map;
 use crate::psbt::{raw, Error};
-use crate::script::ScriptBuf;
+use crate::script::{RedeemScriptBuf, WitnessScriptBuf};
 use crate::taproot::{TapLeafHash, TapTree};
 
 /// Type: Redeem ScriptBuf PSBT_OUT_REDEEM_SCRIPT = 0x00
 const PSBT_OUT_REDEEM_SCRIPT: u64 = 0x00;
 /// Type: Witness ScriptBuf PSBT_OUT_WITNESS_SCRIPT = 0x01
 const PSBT_OUT_WITNESS_SCRIPT: u64 = 0x01;
-/// Type: BIP 32 Derivation Path PSBT_OUT_BIP32_DERIVATION = 0x02
+/// Type: BIP-0032 Derivation Path PSBT_OUT_BIP32_DERIVATION = 0x02
 const PSBT_OUT_BIP32_DERIVATION: u64 = 0x02;
 /// Type: Taproot Internal Key PSBT_OUT_TAP_INTERNAL_KEY = 0x05
 const PSBT_OUT_TAP_INTERNAL_KEY: u64 = 0x05;
 /// Type: Taproot Tree PSBT_OUT_TAP_TREE = 0x06
 const PSBT_OUT_TAP_TREE: u64 = 0x06;
-/// Type: Taproot Key BIP 32 Derivation Path PSBT_OUT_TAP_BIP32_DERIVATION = 0x07
+/// Type: Taproot Key BIP-0032 Derivation Path PSBT_OUT_TAP_BIP32_DERIVATION = 0x07
 const PSBT_OUT_TAP_BIP32_DERIVATION: u64 = 0x07;
-/// Type: Proprietary Use Type PSBT_IN_PROPRIETARY = 0xFC
+/// Type: MuSig2 Public Keys Participating in Aggregate Output PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS = 0x08
+const PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS: u64 = 0x08;
+/// Type: Proprietary Use Type PSBT_OUT_PROPRIETARY = 0xFC
 const PSBT_OUT_PROPRIETARY: u64 = 0xFC;
 
 /// A key-value map for an output of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Output {
     /// The redeem script for this output.
-    pub redeem_script: Option<ScriptBuf>,
+    pub redeem_script: Option<RedeemScriptBuf>,
     /// The witness script for this output.
-    pub witness_script: Option<ScriptBuf>,
+    pub witness_script: Option<WitnessScriptBuf>,
     /// A map from public keys needed to spend this output to their
     /// corresponding master key fingerprints and derivation paths.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub bip32_derivation: BTreeMap<secp256k1::PublicKey, KeySource>,
     /// The internal pubkey.
     pub tap_internal_key: Option<XOnlyPublicKey>,
     /// Taproot Output tree.
     pub tap_tree: Option<TapTree>,
     /// Map of tap root x only keys to origin info and leaf hashes contained in it.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
+    /// Mapping from MuSig2 aggregate keys to the participant keys from which they were aggregated.
+    pub musig2_participant_pubkeys: BTreeMap<secp256k1::PublicKey, Vec<secp256k1::PublicKey>>,
     /// Proprietary key-value pairs for this output.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown key-value pairs for this output.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
 
@@ -58,12 +57,12 @@ impl Output {
         match raw_key.type_value {
             PSBT_OUT_REDEEM_SCRIPT => {
                 impl_psbt_insert_pair! {
-                    self.redeem_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                    self.redeem_script <= <raw_key: _>|<raw_value: RedeemScriptBuf>
                 }
             }
             PSBT_OUT_WITNESS_SCRIPT => {
                 impl_psbt_insert_pair! {
-                    self.witness_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                    self.witness_script <= <raw_key: _>|<raw_value: WitnessScriptBuf>
                 }
             }
             PSBT_OUT_BIP32_DERIVATION => {
@@ -95,6 +94,11 @@ impl Output {
                     self.tap_key_origins <= <raw_key: XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
                 }
             }
+            PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS => {
+                impl_psbt_insert_pair! {
+                    self.musig2_participant_pubkeys <= <raw_key: secp256k1::PublicKey>|< raw_value: Vec<secp256k1::PublicKey> >
+                }
+            }
             _ => match self.unknown.entry(raw_key) {
                 btree_map::Entry::Vacant(empty_key) => {
                     empty_key.insert(raw_value);
@@ -112,6 +116,7 @@ impl Output {
         self.proprietary.extend(other.proprietary);
         self.unknown.extend(other.unknown);
         self.tap_key_origins.extend(other.tap_key_origins);
+        self.musig2_participant_pubkeys.extend(other.musig2_participant_pubkeys);
 
         combine!(redeem_script, self, other);
         combine!(witness_script, self, other);
@@ -148,6 +153,10 @@ impl Map for Output {
             rv.push_map(self.tap_key_origins, PSBT_OUT_TAP_BIP32_DERIVATION)
         }
 
+        impl_psbt_get_pair! {
+            rv.push_map(self.musig2_participant_pubkeys, PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS)
+        }
+
         for (key, value) in self.proprietary.iter() {
             rv.push(raw::Pair { key: key.to_key(), value: value.clone() });
         }
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 9418ae8bf7..1da039448c 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -2,7 +2,7 @@
 
 //! Partially Signed Bitcoin Transactions.
 //!
-//! Implementation of BIP174 Partially Signed Bitcoin Transaction Format as
+//! Implementation of BIP-0174 Partially Signed Bitcoin Transaction Format as
 //! defined at <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
 //! except we define PSBTs containing non-standard sighash types as invalid.
 
@@ -19,17 +19,17 @@ use core::{cmp, fmt};
 use std::collections::{HashMap, HashSet};
 
 use internals::write_err;
-use secp256k1::{Keypair, Message, Secp256k1, Signing, Verification};
+use secp256k1::{Keypair, Message};
 
-use crate::bip32::{self, DerivationPath, KeySource, Xpriv, Xpub};
+use crate::bip32::{self, KeySource, Xpriv, Xpub};
 use crate::crypto::key::{PrivateKey, PublicKey};
 use crate::crypto::{ecdsa, taproot};
 use crate::key::{TapTweak, XOnlyPublicKey};
 use crate::prelude::{btree_map, BTreeMap, BTreeSet, Borrow, Box, Vec};
-use crate::script::ScriptExt as _;
+use crate::script::{ScriptExt as _, ScriptPubKeyExt as _};
 use crate::sighash::{self, EcdsaSighashType, Prevouts, SighashCache};
 use crate::transaction::{self, Transaction, TransactionExt as _, TxOut};
-use crate::{Amount, FeeRate, TapLeafHash, TapSighashType};
+use crate::{Amount, FeeRate, TapLeafHash, TapSighash, TapSighashType};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
@@ -40,7 +40,6 @@ pub use self::{
 
 /// A Partially Signed Transaction.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Psbt {
     /// The unsigned transaction, scriptSigs and witnesses for each input must be empty.
     pub unsigned_tx: Transaction,
@@ -50,10 +49,8 @@ pub struct Psbt {
     /// derivation path as defined by BIP 32.
     pub xpub: BTreeMap<Xpub, KeySource>,
     /// Global proprietary key-value pairs.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown global key-value pairs.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 
     /// The corresponding key-value map for each input in the unsigned transaction.
@@ -76,13 +73,13 @@ impl Psbt {
     ///
     /// The function panics if the length of transaction inputs is not equal to the length of PSBT inputs.
     pub fn iter_funding_utxos(&self) -> impl Iterator<Item = Result<&TxOut, Error>> {
-        assert_eq!(self.inputs.len(), self.unsigned_tx.input.len());
-        self.unsigned_tx.input.iter().zip(&self.inputs).map(|(tx_input, psbt_input)| {
+        assert_eq!(self.inputs.len(), self.unsigned_tx.inputs.len());
+        self.unsigned_tx.inputs.iter().zip(&self.inputs).map(|(tx_input, psbt_input)| {
             match (&psbt_input.witness_utxo, &psbt_input.non_witness_utxo) {
                 (Some(witness_utxo), _) => Ok(witness_utxo),
                 (None, Some(non_witness_utxo)) => {
                     let vout = tx_input.previous_output.vout as usize;
-                    non_witness_utxo.output.get(vout).ok_or(Error::PsbtUtxoOutOfbounds)
+                    non_witness_utxo.outputs.get(vout).ok_or(Error::PsbtUtxoOutOfbounds)
                 }
                 (None, None) => Err(Error::MissingUtxo),
             }
@@ -91,7 +88,7 @@ impl Psbt {
 
     /// Checks that unsigned transaction does not have scriptSig's or witness data.
     fn unsigned_tx_checks(&self) -> Result<(), Error> {
-        for txin in &self.unsigned_tx.input {
+        for txin in &self.unsigned_tx.inputs {
             if !txin.script_sig.is_empty() {
                 return Err(Error::UnsignedTxHasScriptSigs);
             }
@@ -110,9 +107,9 @@ impl Psbt {
     ///
     /// If transactions is not unsigned.
     pub fn from_unsigned_tx(tx: Transaction) -> Result<Self, Error> {
-        let psbt = Psbt {
-            inputs: vec![Default::default(); tx.input.len()],
-            outputs: vec![Default::default(); tx.output.len()],
+        let psbt = Self {
+            inputs: vec![Default::default(); tx.inputs.len()],
+            outputs: vec![Default::default(); tx.outputs.len()],
 
             unsigned_tx: tx,
             xpub: Default::default(),
@@ -130,7 +127,7 @@ impl Psbt {
     /// 1000 sats/vByte. 25k sats/vByte is obviously a mistake at this point.
     ///
     /// [`extract_tx`]: Psbt::extract_tx
-    pub const DEFAULT_MAX_FEE_RATE: FeeRate = FeeRate::from_sat_per_vb_unchecked(25_000);
+    pub const DEFAULT_MAX_FEE_RATE: FeeRate = FeeRate::from_sat_per_vb(25_000);
 
     /// An alias for [`extract_tx_fee_rate_limit`].
     ///
@@ -178,7 +175,7 @@ impl Psbt {
     fn internal_extract_tx(self) -> Transaction {
         let mut tx: Transaction = self.unsigned_tx;
 
-        for (vin, psbtin) in tx.input.iter_mut().zip(self.inputs.into_iter()) {
+        for (vin, psbtin) in tx.inputs.iter_mut().zip(self.inputs.into_iter()) {
             vin.script_sig = psbtin.final_script_sig.unwrap_or_default();
             vin.witness = psbtin.final_script_witness.unwrap_or_default();
         }
@@ -195,7 +192,7 @@ impl Psbt {
         let fee = match self.fee() {
             Ok(fee) => fee,
             Err(Error::MissingUtxo) =>
-                return Err(ExtractTxError::MissingInputValue { tx: self.internal_extract_tx() }),
+                return Err(ExtractTxError::MissingInputAmount { tx: self.internal_extract_tx() }),
             Err(Error::NegativeFee) => return Err(ExtractTxError::SendingTooMuch { psbt: self }),
             Err(Error::FeeOverflow) =>
                 return Err(ExtractTxError::AbsurdFeeRate {
@@ -208,20 +205,17 @@ impl Psbt {
         // Note: Move prevents usage of &self from now on.
         let tx = self.internal_extract_tx();
 
-        // Now that the extracted Transaction is made, decide how to return it.
-        let fee_rate =
-            FeeRate::from_sat_per_kwu(fee.to_sat().saturating_mul(1000) / tx.weight().to_wu());
-        // Prefer to return an AbsurdFeeRate error when both trigger.
+        let fee_rate = (fee / tx.weight()).unwrap_or(FeeRate::MAX);
         if fee_rate > max_fee_rate {
-            return Err(ExtractTxError::AbsurdFeeRate { fee_rate, tx });
+            Err(ExtractTxError::AbsurdFeeRate { fee_rate, tx })
+        } else {
+            Ok(tx)
         }
-
-        Ok(tx)
     }
 
-    /// Combines this [`Psbt`] with `other` PSBT as described by BIP 174.
+    /// Combines this [`Psbt`] with `other` PSBT as described by BIP-0174.
     ///
-    /// In accordance with BIP 174 this function is commutative i.e., `A.combine(B) == B.combine(A)`
+    /// In accordance with BIP-0174 this function is commutative i.e., `A.combine(B) == B.combine(A)`
     pub fn combine(&mut self, other: Self) -> Result<(), Error> {
         if self.unsigned_tx != other.unsigned_tx {
             return Err(Error::UnexpectedUnsignedTx {
@@ -230,7 +224,7 @@ impl Psbt {
             });
         }
 
-        // BIP 174: The Combiner must remove any duplicate key-value pairs, in accordance with
+        // BIP-0174: The Combiner must remove any duplicate key-value pairs, in accordance with
         //          the specification. It can pick arbitrarily when conflicts occur.
 
         // Keeping the highest version
@@ -296,13 +290,8 @@ impl Psbt {
     ///
     /// If an error is returned some signatures may already have been added to the PSBT. Since
     /// `partial_sigs` is a [`BTreeMap`] it is safe to retry, previous sigs will be overwritten.
-    pub fn sign<C, K>(
-        &mut self,
-        k: &K,
-        secp: &Secp256k1<C>,
-    ) -> Result<SigningKeysMap, (SigningKeysMap, SigningErrors)>
+    pub fn sign<K>(&mut self, k: &K) -> Result<SigningKeysMap, (SigningKeysMap, SigningErrors)>
     where
-        C: Signing + Verification,
         K: GetKey,
     {
         let tx = self.unsigned_tx.clone(); // clone because we need to mutably borrow when signing.
@@ -313,25 +302,22 @@ impl Psbt {
 
         for i in 0..self.inputs.len() {
             match self.signing_algorithm(i) {
-                Ok(SigningAlgorithm::Ecdsa) =>
-                    match self.bip32_sign_ecdsa(k, i, &mut cache, secp) {
-                        Ok(v) => {
-                            used.insert(i, SigningKeys::Ecdsa(v));
-                        }
-                        Err(e) => {
-                            errors.insert(i, e);
-                        }
-                    },
-                Ok(SigningAlgorithm::Schnorr) => {
-                    match self.bip32_sign_schnorr(k, i, &mut cache, secp) {
-                        Ok(v) => {
-                            used.insert(i, SigningKeys::Schnorr(v));
-                        }
-                        Err(e) => {
-                            errors.insert(i, e);
-                        }
+                Ok(SigningAlgorithm::Ecdsa) => match self.bip32_sign_ecdsa(k, i, &mut cache) {
+                    Ok(v) => {
+                        used.insert(i, SigningKeys::Ecdsa(v));
                     }
-                }
+                    Err(e) => {
+                        errors.insert(i, e);
+                    }
+                },
+                Ok(SigningAlgorithm::Schnorr) => match self.bip32_sign_schnorr(k, i, &mut cache) {
+                    Ok(v) => {
+                        used.insert(i, SigningKeys::Schnorr(v));
+                    }
+                    Err(e) => {
+                        errors.insert(i, e);
+                    }
+                },
                 Err(e) => {
                     errors.insert(i, e);
                 }
@@ -351,15 +337,13 @@ impl Psbt {
     ///
     /// - Ok: A list of the public keys used in signing.
     /// - Err: Error encountered trying to calculate the sighash AND we had the signing key.
-    fn bip32_sign_ecdsa<C, K, T>(
+    fn bip32_sign_ecdsa<K, T>(
         &mut self,
         k: &K,
         input_index: usize,
         cache: &mut SighashCache<T>,
-        secp: &Secp256k1<C>,
     ) -> Result<Vec<PublicKey>, SignError>
     where
-        C: Signing,
         T: Borrow<Transaction>,
         K: GetKey,
     {
@@ -370,9 +354,9 @@ impl Psbt {
         let mut used = vec![]; // List of pubkeys used to sign the input.
 
         for (pk, key_source) in input.bip32_derivation.iter() {
-            let sk = if let Ok(Some(sk)) = k.get_key(&KeyRequest::Bip32(key_source.clone()), secp) {
+            let sk = if let Ok(Some(sk)) = k.get_key(&KeyRequest::Bip32(key_source.clone())) {
                 sk
-            } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::Pubkey(PublicKey::new(*pk)), secp) {
+            } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::Pubkey(PublicKey::new(*pk))) {
                 sk
             } else {
                 continue;
@@ -385,11 +369,11 @@ impl Psbt {
             };
 
             let sig = ecdsa::Signature {
-                signature: secp.sign_ecdsa(&msg, &sk.inner),
+                signature: secp256k1::ecdsa::sign(msg, &sk.inner),
                 sighash_type: sighash_ty,
             };
 
-            let pk = sk.public_key(secp);
+            let pk = sk.public_key();
 
             input.partial_sigs.insert(pk, sig);
             used.push(pk);
@@ -406,15 +390,13 @@ impl Psbt {
     /// - Ok: A list of the xonly public keys used in signing. When signing a key path spend we
     ///   return the internal key.
     /// - Err: Error encountered trying to calculate the sighash AND we had the signing key.
-    fn bip32_sign_schnorr<C, K, T>(
+    fn bip32_sign_schnorr<K, T>(
         &mut self,
         k: &K,
         input_index: usize,
         cache: &mut SighashCache<T>,
-        secp: &Secp256k1<C>,
     ) -> Result<Vec<XOnlyPublicKey>, SignError>
     where
-        C: Signing + Verification,
         T: Borrow<Transaction>,
         K: GetKey,
     {
@@ -423,11 +405,10 @@ impl Psbt {
         let mut used = vec![]; // List of pubkeys used to sign the input.
 
         for (&xonly, (leaf_hashes, key_source)) in input.tap_key_origins.iter() {
-            let sk = if let Ok(Some(secret_key)) =
-                k.get_key(&KeyRequest::Bip32(key_source.clone()), secp)
+            let sk = if let Ok(Some(secret_key)) = k.get_key(&KeyRequest::Bip32(key_source.clone()))
             {
                 secret_key
-            } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::XOnlyPubkey(xonly), secp) {
+            } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::XOnlyPubkey(xonly)) {
                 sk
             } else {
                 continue;
@@ -440,20 +421,21 @@ impl Psbt {
 
             // key path spend
             if let Some(internal_key) = input.tap_internal_key {
-                // BIP 371: The internal key does not have leaf hashes, so can be indicated with a hashes len of 0.
+                // BIP-0371: The internal key does not have leaf hashes, so can be indicated with a hashes len of 0.
 
                 // Based on input.tap_internal_key.is_some() alone, it is not sufficient to determine whether it is a key path spend.
-                // According to BIP 371, we also need to consider the condition leaf_hashes.is_empty() for a more accurate determination.
+                // According to BIP-0371, we also need to consider the condition leaf_hashes.is_empty() for a more accurate determination.
                 if internal_key == xonly && leaf_hashes.is_empty() && input.tap_key_sig.is_none() {
-                    let (msg, sighash_type) = self.sighash_taproot(input_index, cache, None)?;
-                    let key_pair = Keypair::from_secret_key(secp, &sk.inner)
-                        .tap_tweak(secp, input.tap_merkle_root)
+                    let (sighash, sighash_type) = self.sighash_taproot(input_index, cache, None)?;
+                    let key_pair = Keypair::from_secret_key(&sk.inner)
+                        .tap_tweak(input.tap_merkle_root)
                         .to_keypair();
 
-                    #[cfg(feature = "rand-std")]
-                    let signature = secp.sign_schnorr(msg.as_ref(), &key_pair);
-                    #[cfg(not(feature = "rand-std"))]
-                    let signature = secp.sign_schnorr_no_aux_rand(msg.as_ref(), &key_pair);
+                    #[cfg(all(feature = "rand", feature = "std"))]
+                    let signature = secp256k1::schnorr::sign(&sighash.to_byte_array(), &key_pair);
+                    #[cfg(not(all(feature = "rand", feature = "std")))]
+                    let signature =
+                        secp256k1::schnorr::sign_no_aux_rand(&sighash.to_byte_array(), &key_pair);
 
                     let signature = taproot::Signature { signature, sighash_type };
                     input.tap_key_sig = Some(signature);
@@ -471,22 +453,26 @@ impl Psbt {
                     .collect::<Vec<_>>();
 
                 if !leaf_hashes.is_empty() {
-                    let key_pair = Keypair::from_secret_key(secp, &sk.inner);
+                    let key_pair = Keypair::from_secret_key(&sk.inner);
 
                     for lh in leaf_hashes {
-                        let (msg, sighash_type) =
+                        let (sighash, sighash_type) =
                             self.sighash_taproot(input_index, cache, Some(lh))?;
 
-                        #[cfg(feature = "rand-std")]
-                        let signature = secp.sign_schnorr(msg.as_ref(), &key_pair);
-                        #[cfg(not(feature = "rand-std"))]
-                        let signature = secp.sign_schnorr_no_aux_rand(msg.as_ref(), &key_pair);
+                        #[cfg(all(feature = "rand", feature = "std"))]
+                        let signature =
+                            secp256k1::schnorr::sign(&sighash.to_byte_array(), &key_pair);
+                        #[cfg(not(all(feature = "rand", feature = "std")))]
+                        let signature = secp256k1::schnorr::sign_no_aux_rand(
+                            &sighash.to_byte_array(),
+                            &key_pair,
+                        );
 
                         let signature = taproot::Signature { signature, sighash_type };
                         input.tap_script_sigs.insert((xonly, lh), signature);
                     }
 
-                    used.push(sk.public_key(secp).into());
+                    used.push(sk.public_key().into());
                 }
             }
         }
@@ -534,20 +520,25 @@ impl Psbt {
                 Ok((Message::from(sighash), hash_ty))
             }
             Wpkh => {
-                let sighash = cache.p2wpkh_signature_hash(input_index, spk, utxo.value, hash_ty)?;
+                let sighash =
+                    cache.p2wpkh_signature_hash(input_index, spk, utxo.amount, hash_ty)?;
                 Ok((Message::from(sighash), hash_ty))
             }
             ShWpkh => {
                 let redeem_script = input.redeem_script.as_ref().expect("checked above");
-                let sighash =
-                    cache.p2wpkh_signature_hash(input_index, redeem_script, utxo.value, hash_ty)?;
+                let sighash = cache.p2wpkh_signature_hash(
+                    input_index,
+                    redeem_script,
+                    utxo.amount,
+                    hash_ty,
+                )?;
                 Ok((Message::from(sighash), hash_ty))
             }
             Wsh | ShWsh => {
                 let witness_script =
                     input.witness_script.as_ref().ok_or(SignError::MissingWitnessScript)?;
                 let sighash = cache
-                    .p2wsh_signature_hash(input_index, witness_script, utxo.value, hash_ty)
+                    .p2wsh_signature_hash(input_index, witness_script, utxo.amount, hash_ty)
                     .map_err(SignError::SegwitV0Sighash)?;
                 Ok((Message::from(sighash), hash_ty))
             }
@@ -558,7 +549,7 @@ impl Psbt {
         }
     }
 
-    /// Returns the sighash message to sign an SCHNORR input along with the sighash type.
+    /// Returns the sighash to sign a Taproot input along with the sighash type.
     ///
     /// Uses the [`TapSighashType`] from this input if one is specified. If no sighash type is
     /// specified uses [`TapSighashType::Default`].
@@ -567,7 +558,7 @@ impl Psbt {
         input_index: usize,
         cache: &mut SighashCache<T>,
         leaf_hash: Option<TapLeafHash>,
-    ) -> Result<(Message, TapSighashType), SignError> {
+    ) -> Result<(TapSighash, TapSighashType), SignError> {
         use OutputType::*;
 
         if self.signing_algorithm(input_index)? != SigningAlgorithm::Schnorr {
@@ -612,7 +603,7 @@ impl Psbt {
                 } else {
                     cache.taproot_key_spend_signature_hash(input_index, &prev_outs, hash_ty)?
                 };
-                Ok((Message::from(sighash), hash_ty))
+                Ok((sighash, hash_ty))
             }
             _ => Err(SignError::Unsupported),
         }
@@ -624,8 +615,8 @@ impl Psbt {
         let utxo = if let Some(witness_utxo) = &input.witness_utxo {
             witness_utxo
         } else if let Some(non_witness_utxo) = &input.non_witness_utxo {
-            let vout = self.unsigned_tx.input[input_index].previous_output.vout;
-            &non_witness_utxo.output[vout as usize]
+            let vout = self.unsigned_tx.inputs[input_index].previous_output.vout;
+            &non_witness_utxo.outputs[vout as usize]
         } else {
             return Err(SignError::MissingSpendUtxo);
         };
@@ -654,10 +645,10 @@ impl Psbt {
             });
         }
 
-        if input_index >= self.unsigned_tx.input.len() {
+        if input_index >= self.unsigned_tx.inputs.len() {
             return Err(IndexOutOfBoundsError::TxInput {
                 index: input_index,
-                length: self.unsigned_tx.input.len(),
+                length: self.unsigned_tx.inputs.len(),
             });
         }
 
@@ -670,7 +661,7 @@ impl Psbt {
         Ok(output_type.signing_algorithm())
     }
 
-    /// Returns the [`OutputType`] of the spend utxo for this PBST's input at `input_index`.
+    /// Returns the [`OutputType`] of the spend utxo for this PSBT's input at `input_index`.
     fn output_type(&self, input_index: usize) -> Result<OutputType, SignError> {
         let input = self.checked_input(input_index)?;
         let utxo = self.spend_utxo(input_index)?;
@@ -721,23 +712,68 @@ impl Psbt {
     pub fn fee(&self) -> Result<Amount, Error> {
         let mut inputs = Amount::ZERO;
         for utxo in self.iter_funding_utxos() {
-            inputs = inputs.checked_add(utxo?.value).ok_or(Error::FeeOverflow)?;
+            inputs = inputs.checked_add(utxo?.amount).ok_or(Error::FeeOverflow)?;
         }
         let mut outputs = Amount::ZERO;
-        for out in &self.unsigned_tx.output {
-            outputs = outputs.checked_add(out.value).ok_or(Error::FeeOverflow)?;
+        for out in &self.unsigned_tx.outputs {
+            outputs = outputs.checked_add(out.amount).ok_or(Error::FeeOverflow)?;
         }
         inputs.checked_sub(outputs).ok_or(Error::NegativeFee)
     }
 }
 
+#[cfg(feature = "serde")]
+impl serde::Serialize for Psbt {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        use crate::prelude::ToString;
+
+        if serializer.is_human_readable() {
+            serializer.serialize_str(&self.to_string())
+        } else {
+            serializer.serialize_bytes(&self.serialize())
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Psbt {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl serde::de::Visitor<'_> for Visitor {
+            type Value = Psbt;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a psbt")
+            }
+
+            fn visit_bytes<E: serde::de::Error>(self, bytes: &[u8]) -> Result<Self::Value, E> {
+                Psbt::deserialize(bytes).map_err(|e| serde::de::Error::custom(e))
+            }
+
+            fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<Self::Value, E> {
+                s.parse().map_err(|e| serde::de::Error::custom(e))
+            }
+        }
+
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_str(Visitor)
+        } else {
+            deserializer.deserialize_bytes(Visitor)
+        }
+    }
+}
+
 /// Data required to call [`GetKey`] to get the private key to sign an input.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum KeyRequest {
     /// Request a private key using the associated public key.
     Pubkey(PublicKey),
-    /// Request a private key using BIP-32 fingerprint and derivation path.
+    /// Request a private key using BIP-0032 fingerprint and derivation path.
     Bip32(KeySource),
     /// Request a private key using the associated x-only public key.
     XOnlyPubkey(XOnlyPublicKey),
@@ -755,34 +791,25 @@ pub trait GetKey {
     /// - `Some(key)` if the key is found.
     /// - `None` if the key was not found but no error was encountered.
     /// - `Err` if an error was encountered while looking for the key.
-    fn get_key<C: Signing>(
-        &self,
-        key_request: &KeyRequest,
-        secp: &Secp256k1<C>,
-    ) -> Result<Option<PrivateKey>, Self::Error>;
+    fn get_key(&self, key_request: &KeyRequest) -> Result<Option<PrivateKey>, Self::Error>;
 }
 
 impl GetKey for Xpriv {
     type Error = GetKeyError;
 
-    fn get_key<C: Signing>(
-        &self,
-        key_request: &KeyRequest,
-        secp: &Secp256k1<C>,
-    ) -> Result<Option<PrivateKey>, Self::Error> {
+    fn get_key(&self, key_request: &KeyRequest) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             KeyRequest::Pubkey(_) => Err(GetKeyError::NotSupported),
             KeyRequest::XOnlyPubkey(_) => Err(GetKeyError::NotSupported),
             KeyRequest::Bip32((fingerprint, path)) => {
-                let key = if self.fingerprint(secp) == *fingerprint {
-                    let k = self.derive_xpriv(secp, &path).map_err(GetKeyError::Bip32)?;
+                let key = if self.fingerprint() == *fingerprint {
+                    let k = self.derive_xpriv(path).map_err(GetKeyError::Bip32)?;
                     Some(k.to_private_key())
                 } else if self.parent_fingerprint == *fingerprint
                     && !path.is_empty()
                     && path[0] == self.child_number
                 {
-                    let path = DerivationPath::from_iter(path.into_iter().skip(1).copied());
-                    let k = self.derive_xpriv(secp, &path).map_err(GetKeyError::Bip32)?;
+                    let k = self.derive_xpriv(&path[1..]).map_err(GetKeyError::Bip32)?;
                     Some(k.to_private_key())
                 } else {
                     None
@@ -818,15 +845,14 @@ macro_rules! impl_get_key_for_set {
 impl GetKey for $set<Xpriv> {
     type Error = GetKeyError;
 
-    fn get_key<C: Signing>(
+    fn get_key(
         &self,
         key_request: &KeyRequest,
-        secp: &Secp256k1<C>
     ) -> Result<Option<PrivateKey>, Self::Error> {
         // OK to stop at the first error because Xpriv::get_key() can only fail
         // if this isn't a KeyRequest::Bip32, which would fail for all Xprivs.
         self.iter()
-            .find_map(|xpriv| xpriv.get_key(key_request, secp).transpose())
+            .find_map(|xpriv| xpriv.get_key(key_request).transpose())
             .transpose()
     }
 }}}
@@ -842,21 +868,20 @@ macro_rules! impl_get_key_for_pubkey_map {
 impl GetKey for $map<PublicKey, PrivateKey> {
     type Error = GetKeyError;
 
-    fn get_key<C: Signing>(
+    fn get_key(
         &self,
         key_request: &KeyRequest,
-        _: &Secp256k1<C>,
     ) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             KeyRequest::Pubkey(pk) => Ok(self.get(&pk).cloned()),
             KeyRequest::XOnlyPubkey(xonly) => {
                 let pubkey_even = xonly.public_key(secp256k1::Parity::Even);
                 let key = self.get(&pubkey_even).cloned();
-               
+
                 if key.is_some() {
                     return Ok(key);
                 }
-               
+
                 let pubkey_odd = xonly.public_key(secp256k1::Parity::Odd);
                 if let Some(priv_key) = self.get(&pubkey_odd).copied() {
                     let negated_priv_key  = priv_key.negate();
@@ -880,27 +905,26 @@ macro_rules! impl_get_key_for_xonly_map {
 impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
     type Error = GetKeyError;
 
-    fn get_key<C: Signing>(
+    fn get_key(
         &self,
         key_request: &KeyRequest,
-        secp: &Secp256k1<C>,
     ) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             KeyRequest::XOnlyPubkey(xonly) => Ok(self.get(xonly).cloned()),
             KeyRequest::Pubkey(pk) => {
                 let (xonly, parity) = pk.inner.x_only_public_key();
-               
+
                 if let Some(mut priv_key) = self.get(&XOnlyPublicKey::from(xonly)).cloned() {
-                    let computed_pk = priv_key.public_key(&secp);
+                    let computed_pk = priv_key.public_key();
                     let (_, computed_parity) = computed_pk.inner.x_only_public_key();
-                   
+
                     if computed_parity != parity {
                         priv_key = priv_key.negate();
                     }
-                   
+
                     return Ok(Some(priv_key));
                 }
-               
+
                 Ok(None)
             },
             KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
@@ -927,11 +951,9 @@ impl From<Infallible> for GetKeyError {
 
 impl fmt::Display for GetKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use GetKeyError::*;
-
-        match *self {
-            Bip32(ref e) => write_err!(f, "bip32 derivation"; e),
-            NotSupported =>
+        match self {
+            Self::Bip32(ref e) => write_err!(f, "bip32 derivation"; e),
+            Self::NotSupported =>
                 f.write_str("the GetKey operation is not supported for this key request"),
         }
     }
@@ -940,11 +962,9 @@ impl fmt::Display for GetKeyError {
 #[cfg(feature = "std")]
 impl std::error::Error for GetKeyError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use GetKeyError::*;
-
-        match *self {
-            NotSupported => None,
-            Bip32(ref e) => Some(e),
+        match self {
+            Self::NotSupported => None,
+            Self::Bip32(ref e) => Some(e),
         }
     }
 }
@@ -1012,7 +1032,7 @@ pub enum SignError {
     MissingWitnessScript,
     /// Signing algorithm and key type does not match.
     MismatchedAlgoKey,
-    /// Attempted to ECDSA sign an non-ECDSA input.
+    /// Attempted to ECDSA sign a non-ECDSA input.
     NotEcdsa,
     /// The `scriptPubkey` is not a P2WPKH script.
     NotWpkh,
@@ -1038,26 +1058,24 @@ impl From<Infallible> for SignError {
 
 impl fmt::Display for SignError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use SignError::*;
-
-        match *self {
-            IndexOutOfBounds(ref e) => write_err!(f, "index out of bounds"; e),
-            InvalidSighashType => write!(f, "invalid sighash type"),
-            MissingInputUtxo => write!(f, "missing input utxo in PBST"),
-            MissingRedeemScript => write!(f, "missing redeem script"),
-            MissingSpendUtxo => write!(f, "missing spend utxo in PSBT"),
-            MissingWitnessScript => write!(f, "missing witness script"),
-            MismatchedAlgoKey => write!(f, "signing algorithm and key type does not match"),
-            NotEcdsa => write!(f, "attempted to ECDSA sign an non-ECDSA input"),
-            NotWpkh => write!(f, "the scriptPubkey is not a P2WPKH script"),
-            SegwitV0Sighash(ref e) => write_err!(f, "SegWit v0 sighash"; e),
-            P2wpkhSighash(ref e) => write_err!(f, "p2wpkh sighash"; e),
-            TaprootError(ref e) => write_err!(f, "Taproot sighash"; e),
-            UnknownOutputType => write!(f, "unable to determine the output type"),
-            KeyNotFound => write!(f, "unable to find key"),
-            WrongSigningAlgorithm =>
+        match self {
+            Self::IndexOutOfBounds(ref e) => write_err!(f, "index out of bounds"; e),
+            Self::InvalidSighashType => write!(f, "invalid sighash type"),
+            Self::MissingInputUtxo => write!(f, "missing input utxo in PSBT"),
+            Self::MissingRedeemScript => write!(f, "missing redeem script"),
+            Self::MissingSpendUtxo => write!(f, "missing spend utxo in PSBT"),
+            Self::MissingWitnessScript => write!(f, "missing witness script"),
+            Self::MismatchedAlgoKey => write!(f, "signing algorithm and key type does not match"),
+            Self::NotEcdsa => write!(f, "attempted to ECDSA sign a non-ECDSA input"),
+            Self::NotWpkh => write!(f, "the scriptPubkey is not a P2WPKH script"),
+            Self::SegwitV0Sighash(ref e) => write_err!(f, "SegWit v0 sighash"; e),
+            Self::P2wpkhSighash(ref e) => write_err!(f, "p2wpkh sighash"; e),
+            Self::TaprootError(ref e) => write_err!(f, "Taproot sighash"; e),
+            Self::UnknownOutputType => write!(f, "unable to determine the output type"),
+            Self::KeyNotFound => write!(f, "unable to find key"),
+            Self::WrongSigningAlgorithm =>
                 write!(f, "attempt to sign an input with the wrong signing algorithm"),
-            Unsupported => write!(f, "signing request currently unsupported"),
+            Self::Unsupported => write!(f, "signing request currently unsupported"),
         }
     }
 }
@@ -1065,25 +1083,23 @@ impl fmt::Display for SignError {
 #[cfg(feature = "std")]
 impl std::error::Error for SignError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use SignError::*;
-
-        match *self {
-            SegwitV0Sighash(ref e) => Some(e),
-            P2wpkhSighash(ref e) => Some(e),
-            TaprootError(ref e) => Some(e),
-            IndexOutOfBounds(ref e) => Some(e),
-            InvalidSighashType
-            | MissingInputUtxo
-            | MissingRedeemScript
-            | MissingSpendUtxo
-            | MissingWitnessScript
-            | MismatchedAlgoKey
-            | NotEcdsa
-            | NotWpkh
-            | UnknownOutputType
-            | KeyNotFound
-            | WrongSigningAlgorithm
-            | Unsupported => None,
+        match self {
+            Self::SegwitV0Sighash(ref e) => Some(e),
+            Self::P2wpkhSighash(ref e) => Some(e),
+            Self::TaprootError(ref e) => Some(e),
+            Self::IndexOutOfBounds(ref e) => Some(e),
+            Self::InvalidSighashType
+            | Self::MissingInputUtxo
+            | Self::MissingRedeemScript
+            | Self::MissingSpendUtxo
+            | Self::MissingWitnessScript
+            | Self::MismatchedAlgoKey
+            | Self::NotEcdsa
+            | Self::NotWpkh
+            | Self::UnknownOutputType
+            | Self::KeyNotFound
+            | Self::WrongSigningAlgorithm
+            | Self::Unsupported => None,
         }
     }
 }
@@ -1093,11 +1109,11 @@ impl From<sighash::P2wpkhError> for SignError {
 }
 
 impl From<IndexOutOfBoundsError> for SignError {
-    fn from(e: IndexOutOfBoundsError) -> Self { SignError::IndexOutOfBounds(e) }
+    fn from(e: IndexOutOfBoundsError) -> Self { Self::IndexOutOfBounds(e) }
 }
 
 impl From<sighash::TaprootError> for SignError {
-    fn from(e: sighash::TaprootError) -> Self { SignError::TaprootError(e) }
+    fn from(e: sighash::TaprootError) -> Self { Self::TaprootError(e) }
 }
 
 /// This error is returned when extracting a [`Transaction`] from a [`Psbt`].
@@ -1111,12 +1127,12 @@ pub enum ExtractTxError {
         /// The extracted [`Transaction`] (use this to ignore the error)
         tx: Transaction,
     },
-    /// One or more of the inputs lacks value information (witness_utxo or non_witness_utxo)
-    MissingInputValue {
+    /// One or more of the inputs lacks amount information (witness_utxo or non_witness_utxo)
+    MissingInputAmount {
         /// The extracted [`Transaction`] (use this to ignore the error)
         tx: Transaction,
     },
-    /// Input value is less than Output Value, and the [`Transaction`] would be invalid.
+    /// Input amount is less than output amount, and the [`Transaction`] would be invalid.
     SendingTooMuch {
         /// The original [`Psbt`] is returned untouched.
         psbt: Psbt,
@@ -1129,18 +1145,19 @@ impl From<Infallible> for ExtractTxError {
 
 impl fmt::Display for ExtractTxError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use ExtractTxError::*;
-
-        match *self {
-            AbsurdFeeRate { fee_rate, .. } =>
-                write!(f, "an absurdly high fee rate of {} sat/kwu", fee_rate.to_sat_per_kwu()),
-            MissingInputValue { .. } => write!(
+        match self {
+            Self::AbsurdFeeRate { fee_rate, .. } => write!(
                 f,
-                "one of the inputs lacked value information (witness_utxo or non_witness_utxo)"
+                "an absurdly high fee rate of {} sat/kwu",
+                fee_rate.to_sat_per_kwu_floor()
             ),
-            SendingTooMuch { .. } => write!(
+            Self::MissingInputAmount { .. } => write!(
                 f,
-                "transaction would be invalid due to output value being greater than input value."
+                "one of the inputs lacked amount information (witness_utxo or non_witness_utxo)"
+            ),
+            Self::SendingTooMuch { .. } => write!(
+                f,
+                "transaction would be invalid due to output amount being greater than input amount."
             ),
         }
     }
@@ -1149,10 +1166,10 @@ impl fmt::Display for ExtractTxError {
 #[cfg(feature = "std")]
 impl std::error::Error for ExtractTxError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ExtractTxError::*;
-
-        match *self {
-            AbsurdFeeRate { .. } | MissingInputValue { .. } | SendingTooMuch { .. } => None,
+        match self {
+            Self::AbsurdFeeRate { .. }
+            | Self::MissingInputAmount { .. }
+            | Self::SendingTooMuch { .. } => None,
         }
     }
 }
@@ -1165,14 +1182,14 @@ pub enum IndexOutOfBoundsError {
     Inputs {
         /// Attempted index access.
         index: usize,
-        /// Length of the PBST inputs vector.
+        /// Length of the PSBT inputs vector.
         length: usize,
     },
     /// The index is out of bounds for the `psbt.unsigned_tx.input` vector.
     TxInput {
         /// Attempted index access.
         index: usize,
-        /// Length of the PBST's unsigned transaction input vector.
+        /// Length of the PSBT's unsigned transaction input vector.
         length: usize,
     },
 }
@@ -1183,15 +1200,13 @@ impl From<Infallible> for IndexOutOfBoundsError {
 
 impl fmt::Display for IndexOutOfBoundsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use IndexOutOfBoundsError::*;
-
-        match *self {
-            Inputs { ref index, ref length } => write!(
+        match self {
+            Self::Inputs { ref index, ref length } => write!(
                 f,
                 "index {} is out-of-bounds for PSBT inputs vector length {}",
                 index, length
             ),
-            TxInput { ref index, ref length } => write!(
+            Self::TxInput { ref index, ref length } => write!(
                 f,
                 "index {} is out-of-bounds for PSBT unsigned tx input vector length {}",
                 index, length
@@ -1203,10 +1218,8 @@ impl fmt::Display for IndexOutOfBoundsError {
 #[cfg(feature = "std")]
 impl std::error::Error for IndexOutOfBoundsError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use IndexOutOfBoundsError::*;
-
-        match *self {
-            Inputs { .. } | TxInput { .. } => None,
+        match self {
+            Self::Inputs { .. } | Self::TxInput { .. } => None,
         }
     }
 }
@@ -1239,11 +1252,10 @@ mod display_from_str {
 
     impl fmt::Display for PsbtParseError {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            use self::PsbtParseError::*;
-
-            match *self {
-                PsbtEncoding(ref e) => write_err!(f, "error in internal PSBT data structure"; e),
-                Base64Encoding(ref e) => write_err!(f, "error in PSBT base64 encoding"; e),
+            match self {
+                Self::PsbtEncoding(ref e) =>
+                    write_err!(f, "error in internal PSBT data structure"; e),
+                Self::Base64Encoding(ref e) => write_err!(f, "error in PSBT base64 encoding"; e),
             }
         }
     }
@@ -1251,11 +1263,9 @@ mod display_from_str {
     #[cfg(feature = "std")]
     impl std::error::Error for PsbtParseError {
         fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-            use self::PsbtParseError::*;
-
             match self {
-                PsbtEncoding(e) => Some(e),
-                Base64Encoding(e) => Some(e),
+                Self::PsbtEncoding(e) => Some(e),
+                Self::Base64Encoding(e) => Some(e),
             }
         }
     }
@@ -1271,7 +1281,7 @@ mod display_from_str {
 
         fn from_str(s: &str) -> Result<Self, Self::Err> {
             let data = BASE64_STANDARD.decode(s).map_err(PsbtParseError::Base64Encoding)?;
-            Psbt::deserialize(&data).map_err(PsbtParseError::PsbtEncoding)
+            Self::deserialize(&data).map_err(PsbtParseError::PsbtEncoding)
         }
     }
 }
@@ -1280,35 +1290,29 @@ pub use self::display_from_str::PsbtParseError;
 
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
     use hashes::{hash160, ripemd160, sha256};
     use hex::FromHex;
     use hex_lit::hex;
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     use {
-        crate::address::script_pubkey::ScriptBufExt as _,
-        crate::bip32::{DerivationPath, Fingerprint},
-        crate::locktime,
-        crate::witness_version::WitnessVersion,
-        crate::WitnessProgram,
-        secp256k1::{All, SecretKey},
+        crate::bip32::Fingerprint, crate::locktime, crate::script::ScriptPubKeyBufExt as _,
+        crate::witness_version::WitnessVersion, crate::WitnessProgram, secp256k1::SecretKey,
     };
 
     use super::*;
-    use crate::address::script_pubkey::ScriptExt as _;
-    use crate::bip32::ChildNumber;
+    use crate::bip32::{ChildNumber, DerivationPath};
     use crate::locktime::absolute;
     use crate::network::NetworkKind;
     use crate::psbt::serialize::{Deserialize, Serialize};
-    use crate::script::{ScriptBuf, ScriptBufExt as _};
+    use crate::script::{
+        RedeemScriptBuf, ScriptBufExt as _, ScriptPubKeyBuf, ScriptSigBuf, WitnessScriptBuf,
+    };
     use crate::transaction::{self, OutPoint, TxIn};
     use crate::witness::Witness;
     use crate::Sequence;
 
-    /// Fee rate in sat/kwu for a high-fee PSBT with an input=5_000_000_000_000, output=1000
-    const ABSURD_FEE_RATE: FeeRate = FeeRate::from_sat_per_kwu(15_060_240_960_843);
-    /// Fee rate which is just below absurd threshold (1 sat/kwu less)
-    const JUST_BELOW_ABSURD_FEE_RATE: FeeRate = FeeRate::from_sat_per_kwu(15_060_240_960_842);
-
     #[track_caller]
     pub fn hex_psbt(s: &str) -> Result<Psbt, crate::psbt::error::Error> {
         let r = Vec::from_hex(s);
@@ -1319,25 +1323,25 @@ mod tests {
     }
 
     #[track_caller]
-    fn psbt_with_values(input: u64, output: u64) -> Psbt {
+    fn psbt_with_amounts(input: u64, output: u64) -> Psbt {
         Psbt {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::ZERO,
-                input: vec![TxIn {
+                inputs: vec![TxIn {
                     previous_output: OutPoint {
                         txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126"
                             .parse()
                             .unwrap(),
                         vout: 0,
                     },
-                    script_sig: ScriptBuf::new(),
+                    script_sig: ScriptSigBuf::new(),
                     sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
                     witness: Witness::default(),
                 }],
-                output: vec![TxOut {
-                    value: Amount::from_sat(output).unwrap(),
-                    script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+                outputs: vec![TxOut {
+                    amount: Amount::from_sat(output).unwrap(),
+                    script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                         "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                     )
                     .unwrap(),
@@ -1350,8 +1354,8 @@ mod tests {
 
             inputs: vec![Input {
                 witness_utxo: Some(TxOut {
-                    value: Amount::from_sat(input).unwrap(),
-                    script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+                    amount: Amount::from_sat(input).unwrap(),
+                    script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                         "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
                     )
                     .unwrap(),
@@ -1368,8 +1372,8 @@ mod tests {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::ZERO,
-                input: vec![],
-                output: vec![],
+                inputs: vec![],
+                outputs: vec![],
             },
             xpub: Default::default(),
             version: 0,
@@ -1392,58 +1396,67 @@ mod tests {
 
     #[test]
     fn psbt_high_fee_checks() {
-        let psbt = psbt_with_values(5_000_000_000_000, 1000);
+        let psbt = psbt_with_amounts(Amount::MAX.to_sat(), 1000);
+
+        // We cannot create an expected fee rate to test against because `FeeRate::from_sat_per_mvb` is private.
+        // Large fee rate errors if we pass in 1 sat/vb so just use this to get the error fee rate returned.
+        let error_fee_rate = psbt
+            .clone()
+            .extract_tx_with_fee_rate_limit(FeeRate::from_sat_per_vb(1))
+            .map_err(|e| match e {
+                ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
+                other => panic!("expected AbsurdFeeRate error, got {other:?}"),
+            })
+            .unwrap_err();
+
+        // In `internal_extract_tx_with_fee_rate_limit` when we do fee / weight
+        // we manually saturate to `FeeRate::MAX`.
+        assert!(psbt.clone().extract_tx_with_fee_rate_limit(FeeRate::MAX).is_ok());
+
+        // These error because the fee rate is above the limit as expected.
         assert_eq!(
             psbt.clone().extract_tx().map_err(|e| match e {
                 ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
-                _ => panic!(""),
+                other => panic!("expected AbsurdFeeRate error, got {other:?}"),
             }),
-            Err(ABSURD_FEE_RATE)
+            Err(error_fee_rate)
         );
         assert_eq!(
-            psbt.clone().extract_tx_fee_rate_limit().map_err(|e| match e {
+            psbt.extract_tx_fee_rate_limit().map_err(|e| match e {
                 ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
-                _ => panic!(""),
+                other => panic!("expected AbsurdFeeRate error, got {other:?}"),
             }),
-            Err(ABSURD_FEE_RATE)
-        );
-        assert_eq!(
-            psbt.clone()
-                .extract_tx_with_fee_rate_limit(JUST_BELOW_ABSURD_FEE_RATE)
-                .map_err(|e| match e {
-                    ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
-                    _ => panic!(""),
-                }),
-            Err(ABSURD_FEE_RATE)
+            Err(error_fee_rate)
         );
-        assert!(psbt
-            .extract_tx_with_fee_rate_limit(ABSURD_FEE_RATE)
-            .is_ok());
+
+        // No one is using an ~50 BTC fee so if we can handle this
+        // then the `FeeRate` restrictions are fine for PSBT usage.
+        let psbt = psbt_with_amounts(Amount::from_btc_u16(50).to_sat(), 1000); // fee = 50 BTC - 1000 sats
+        assert!(psbt.extract_tx_with_fee_rate_limit(FeeRate::MAX).is_ok());
 
         // Testing that extract_tx will error at 25k sat/vbyte (6250000 sat/kwu)
         assert_eq!(
-            psbt_with_values(2076001, 1000).extract_tx().map_err(|e| match e {
+            psbt_with_amounts(2076001, 1000).extract_tx().map_err(|e| match e {
                 ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
-                _ => panic!(""),
+                other => panic!("expected AbsurdFeeRate error, got {other:?}"),
             }),
             Err(FeeRate::from_sat_per_kwu(6250003)) // 6250000 is 25k sat/vbyte
         );
 
         // Lowering the input satoshis by 1 lowers the sat/kwu by 3
         // Putting it exactly at 25k sat/vbyte
-        assert!(psbt_with_values(2076000, 1000).extract_tx().is_ok());
+        assert!(psbt_with_amounts(2076000, 1000).extract_tx().is_ok());
     }
 
     #[test]
     fn serialize_then_deserialize_output() {
-        let secp = &Secp256k1::new();
         let seed = hex!("000102030405060708090a0b0c0d0e0f");
 
         let mut hd_keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = Default::default();
 
         let mut sk: Xpriv = Xpriv::new_master(NetworkKind::Main, &seed);
 
-        let fprint = sk.fingerprint(secp);
+        let fprint = sk.fingerprint();
 
         let dpath: Vec<ChildNumber> = vec![
             ChildNumber::ZERO_NORMAL,
@@ -1456,21 +1469,21 @@ mod tests {
             ChildNumber::from_normal_idx(31337).unwrap(),
         ];
 
-        sk = sk.derive_xpriv(secp, &dpath).unwrap();
+        sk = sk.derive_xpriv(&dpath).unwrap();
 
-        let pk = Xpub::from_xpriv(secp, &sk);
+        let pk = Xpub::from_xpriv(&sk);
 
         hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
 
         let expected: Output = Output {
             redeem_script: Some(
-                ScriptBuf::from_hex_no_length_prefix(
+                RedeemScriptBuf::from_hex_no_length_prefix(
                     "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac",
                 )
                 .unwrap(),
             ),
             witness_script: Some(
-                ScriptBuf::from_hex_no_length_prefix(
+                WitnessScriptBuf::from_hex_no_length_prefix(
                     "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                 )
                 .unwrap(),
@@ -1490,28 +1503,28 @@ mod tests {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::from_consensus(1257139),
-                input: vec![TxIn {
+                inputs: vec![TxIn {
                     previous_output: OutPoint {
                         txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126"
                             .parse()
                             .unwrap(),
                         vout: 0,
                     },
-                    script_sig: ScriptBuf::new(),
+                    script_sig: ScriptSigBuf::new(),
                     sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
                     witness: Witness::default(),
                 }],
-                output: vec![
+                outputs: vec![
                     TxOut {
-                        value: Amount::from_sat_u32(99_999_699),
-                        script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+                        amount: Amount::from_sat_u32(99_999_699),
+                        script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                             "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac",
                         )
                         .unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat_u32(100_000_000),
-                        script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+                        amount: Amount::from_sat_u32(100_000_000),
+                        script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                             "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                         )
                         .unwrap(),
@@ -1561,14 +1574,14 @@ mod tests {
         let tx = Transaction {
             version: transaction::Version::ONE,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![TxIn {
+            inputs: vec![TxIn {
                 previous_output: OutPoint {
                     txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
                         .parse()
                         .unwrap(),
                     vout: 1,
                 },
-                script_sig: ScriptBuf::from_hex_no_length_prefix(
+                script_sig: ScriptSigBuf::from_hex_no_length_prefix(
                     "160014be18d152a9b012039daf3da7de4f53349eecb985",
                 )
                 .unwrap(),
@@ -1577,16 +1590,16 @@ mod tests {
                     "03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105"
                 )]),
             }],
-            output: vec![TxOut {
-                value: Amount::from_sat(190_303_501_938).unwrap(),
-                script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+            outputs: vec![TxOut {
+                amount: Amount::from_sat(190_303_501_938).unwrap(),
+                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                     "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
                 )
                 .unwrap(),
             }],
         };
         let unknown: BTreeMap<raw::Key, Vec<u8>> =
-            vec![(raw::Key { type_value: 1, key_data: vec![0, 1] }, vec![3, 4, 5])]
+            vec![(raw::Key { type_value: 42, key_data: vec![0, 1] }, vec![3, 4, 5])]
                 .into_iter()
                 .collect();
         let key_source = ("deadbeef".parse().unwrap(), "0'/1".parse().unwrap());
@@ -1618,8 +1631,9 @@ mod tests {
             },
             unsigned_tx: {
                 let mut unsigned = tx.clone();
-                unsigned.input[0].script_sig = ScriptBuf::new();
-                unsigned.input[0].witness = Witness::default();
+                unsigned.inputs[0].previous_output.txid = tx.compute_txid();
+                unsigned.inputs[0].script_sig = ScriptSigBuf::new();
+                unsigned.inputs[0].witness = Witness::default();
                 unsigned
             },
             proprietary: proprietary.clone(),
@@ -1629,8 +1643,8 @@ mod tests {
                 Input {
                     non_witness_utxo: Some(tx),
                     witness_utxo: Some(TxOut {
-                        value: Amount::from_sat(190_303_501_938).unwrap(),
-                        script_pubkey: ScriptBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                        amount: Amount::from_sat(190_303_501_938).unwrap(),
+                        script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                     }),
                     sighash_type: Some("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<PsbtSighashType>().unwrap()),
                     redeem_script: Some(vec![0x51].into()),
@@ -1641,10 +1655,10 @@ mod tests {
                     )].into_iter().collect(),
                     bip32_derivation: keypaths.clone(),
                     final_script_witness: Some(Witness::from_slice(&[vec![1, 3], vec![5]])),
-                    ripemd160_preimages: vec![(ripemd160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-                    sha256_preimages: vec![(sha256::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-                    hash160_preimages: vec![(hash160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
-                    hash256_preimages: vec![(sha256d::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
+                    ripemd160_preimages: vec![(ripemd160::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+                    sha256_preimages: vec![(sha256::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+                    hash160_preimages: vec![(hash160::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+                    hash256_preimages: vec![(sha256d::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
                     proprietary: proprietary.clone(),
                     unknown: unknown.clone(),
                     ..Default::default()
@@ -1741,25 +1755,25 @@ mod tests {
                 unsigned_tx: Transaction {
                     version: transaction::Version::TWO,
                     lock_time: absolute::LockTime::from_consensus(1257139),
-                    input: vec![
+                    inputs: vec![
                         TxIn {
                             previous_output: OutPoint {
                                 txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
                                 vout: 0,
                             },
-                            script_sig: ScriptBuf::new(),
+                            script_sig: ScriptSigBuf::new(),
                             sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
                             witness: Witness::default(),
                         }
                     ],
-                    output: vec![
+                    outputs: vec![
                         TxOut {
-                            value: Amount::from_sat_u32(99_999_699),
-                            script_pubkey: ScriptBuf::from_hex_no_length_prefix("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
+                            amount: Amount::from_sat_u32(99_999_699),
+                            script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                         },
                         TxOut {
-                            value: Amount::from_sat_u32(100_000_000),
-                            script_pubkey: ScriptBuf::from_hex_no_length_prefix("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
+                            amount: Amount::from_sat_u32(100_000_000),
+                            script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                         },
                     ],
                 },
@@ -1773,13 +1787,13 @@ mod tests {
                         non_witness_utxo: Some(Transaction {
                             version: transaction::Version::ONE,
                             lock_time: absolute::LockTime::ZERO,
-                            input: vec![
+                            inputs: vec![
                                 TxIn {
                                     previous_output: OutPoint {
                                         txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
                                         vout: 1,
                                     },
-                                    script_sig: ScriptBuf::from_hex_no_length_prefix("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
+                                    script_sig: ScriptSigBuf::from_hex_no_length_prefix("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
                                     sequence: Sequence::MAX,
                                     witness: Witness::from_slice(&[
                                         hex!("304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c01").as_slice(),
@@ -1791,7 +1805,7 @@ mod tests {
                                         txid: "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886".parse().unwrap(),
                                         vout: 1,
                                     },
-                                    script_sig: ScriptBuf::from_hex_no_length_prefix("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
+                                    script_sig: ScriptSigBuf::from_hex_no_length_prefix("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
                                     sequence: Sequence::MAX,
                                     witness: Witness::from_slice(&[
                                         hex!("3045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01").as_slice(),
@@ -1799,14 +1813,14 @@ mod tests {
                                     ]),
                                 }
                             ],
-                            output: vec![
+                            outputs: vec![
                                 TxOut {
-                                    value: Amount::from_sat_u32(200_000_000),
-                                    script_pubkey: ScriptBuf::from_hex_no_length_prefix("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
+                                    amount: Amount::from_sat_u32(200_000_000),
+                                    script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                                 },
                                 TxOut {
-                                    value: Amount::from_sat(190_303_501_938).unwrap(),
-                                    script_pubkey: ScriptBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                                    amount: Amount::from_sat(190_303_501_938).unwrap(),
+                                    script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                                 },
                             ],
                         }),
@@ -1847,7 +1861,7 @@ mod tests {
             assert!(&psbt.inputs[0].final_script_sig.is_some());
 
             let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
-            let expected_out = ScriptBuf::from_hex_no_length_prefix(
+            let expected_out = ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
             )
             .unwrap();
@@ -1871,11 +1885,11 @@ mod tests {
             assert_eq!(psbt.inputs.len(), 1);
             assert_eq!(psbt.outputs.len(), 2);
 
-            let tx_input = &psbt.unsigned_tx.input[0];
+            let tx_input = &psbt.unsigned_tx.inputs[0];
             let psbt_non_witness_utxo = psbt.inputs[0].non_witness_utxo.as_ref().unwrap();
 
             assert_eq!(tx_input.previous_output.txid, psbt_non_witness_utxo.compute_txid());
-            assert!(psbt_non_witness_utxo.output[tx_input.previous_output.vout as usize]
+            assert!(psbt_non_witness_utxo.outputs[tx_input.previous_output.vout as usize]
                 .script_pubkey
                 .is_p2pkh());
             assert_eq!(
@@ -1895,7 +1909,7 @@ mod tests {
             assert!(&psbt.inputs[1].final_script_sig.is_none());
 
             let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
-            let expected_out = ScriptBuf::from_hex_no_length_prefix(
+            let expected_out = ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
             )
             .unwrap();
@@ -1922,7 +1936,7 @@ mod tests {
             assert!(&psbt.inputs[0].final_script_sig.is_none());
 
             let redeem_script = psbt.inputs[0].redeem_script.as_ref().unwrap();
-            let expected_out = ScriptBuf::from_hex_no_length_prefix(
+            let expected_out = ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87",
             )
             .unwrap();
@@ -2063,6 +2077,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn invalid_vector_4617() {
+        let err = hex_psbt("70736274ff01007374ff0103010000000000000000002e2873007374ff0107736205000000000000000000000000000000000006060005feffffff74ff01000a000000000000002cc760008530b38dac0100030500000074ff01070100000000000000000000000000c0316888e006000600050000736274ff00d90001007374ff41030100000000000a0a06002e2873007374ff01070100000000000000000000000000000000ff0000060600050000736274ff01000a0080000000000024c7600005193b1e400700030500000074ff0107010000000000a9c7df3f07000570ed62c76004c3ca95c5f90200010742420a0a000000000000").unwrap_err();
+        match err {
+            Error::IncorrectNonWitnessUtxo { index: 0, input_outpoint, non_witness_utxo_txid } => {
+                assert_eq!(
+                    input_outpoint,
+                    "00000000000000000000000562730701ff74730073282e000000000000000000:0"
+                        .parse()
+                        .unwrap(),
+                );
+                assert_eq!(
+                    non_witness_utxo_txid,
+                    "9ed45fd3f73b038649bee6e763dbd70868745c48a0d2b0299f42c68f957995f4"
+                        .parse()
+                        .unwrap(),
+                );
+            }
+            _ => panic!("expected output hash mismatch error, got {}", err),
+        }
+    }
+
     #[test]
     fn serialize_and_deserialize_preimage_psbt() {
         // create a sha preimage map
@@ -2080,25 +2116,26 @@ mod tests {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::from_consensus(1257139),
-                input: vec![
+                inputs: vec![
                     TxIn {
                         previous_output: OutPoint {
                             txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
                             vout: 0,
                         },
-                        script_sig: ScriptBuf::new(),
+                        script_sig: ScriptSigBuf::new(),
                         sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
                         witness: Witness::default(),
                     }
                 ],
-                output: vec![
+                outputs: vec![
                     TxOut {
-                        value: Amount::from_sat_u32(99_999_699),
-                        script_pubkey: ScriptBuf::from_hex_no_length_prefix("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
+                        amount: Amount::from_sat_u32(99_999_699),
+                        script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat_u32(100_000_000),
-                        script_pubkey: ScriptBuf::from_hex_no_length_prefix("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
+
+                        amount: Amount::from_sat_u32(100_000_000),
+                        script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                     },
                 ],
             },
@@ -2112,13 +2149,13 @@ mod tests {
                     non_witness_utxo: Some(Transaction {
                         version: transaction::Version::ONE,
                         lock_time: absolute::LockTime::ZERO,
-                        input: vec![
+                        inputs: vec![
                             TxIn {
                                 previous_output: OutPoint {
                                     txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
                                     vout: 1,
                                 },
-                                script_sig: ScriptBuf::from_hex_no_length_prefix("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
+                                script_sig: ScriptSigBuf::from_hex_no_length_prefix("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
                                 sequence: Sequence::MAX,
                                 witness: Witness::from_slice(&[
                                     hex!("304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c01").as_slice(),
@@ -2130,7 +2167,7 @@ mod tests {
                                     txid: "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886".parse().unwrap(),
                                     vout: 1,
                                 },
-                                script_sig: ScriptBuf::from_hex_no_length_prefix("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
+                                script_sig: ScriptSigBuf::from_hex_no_length_prefix("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
                                 sequence: Sequence::MAX,
                                 witness: Witness::from_slice(&[
                                     hex!("3045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01").as_slice(),
@@ -2138,14 +2175,14 @@ mod tests {
                                 ]),
                             }
                         ],
-                        output: vec![
+                        outputs: vec![
                             TxOut {
-                                value: Amount::from_sat_u32(200_000_000),
-                                script_pubkey: ScriptBuf::from_hex_no_length_prefix("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
+                                amount: Amount::from_sat_u32(200_000_000),
+                                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                             },
                             TxOut {
-                                value: Amount::from_sat(190_303_501_938).unwrap(),
-                                script_pubkey: ScriptBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                                amount: Amount::from_sat(190_303_501_938).unwrap(),
+                                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                             },
                         ],
                     }),
@@ -2167,7 +2204,7 @@ mod tests {
         let rtt = hex_psbt(&unserialized.serialize_hex()).unwrap();
         assert_eq!(rtt, unserialized);
 
-        // Now add an ripemd160 with incorrect preimage
+        // Now add a ripemd160 with incorrect preimage
         let mut ripemd160_preimages = BTreeMap::new();
         ripemd160_preimages.insert(ripemd160::Hash::hash(&[17u8]), vec![18u8]);
         unserialized.inputs[0].ripemd160_preimages = ripemd160_preimages;
@@ -2189,6 +2226,67 @@ mod tests {
         assert!(!rtt.proprietary.is_empty());
     }
 
+    // Deserialize MuSig2 PSBT participant keys according to BIP-0373
+    #[test]
+    fn serialize_and_deserialize_musig2_participants() {
+        // XXX: Does not cover PSBT_IN_MUSIG2_PUB_NONCE, PSBT_IN_MUSIG2_PARTIAL_SIG (yet)
+
+        let expected_in_agg_pk = secp256k1::PublicKey::from_str(
+            "021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00",
+        )
+        .unwrap();
+        let expected_in_pubkeys = vec![
+            secp256k1::PublicKey::from_str(
+                "02bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a",
+            )
+            .unwrap(),
+            secp256k1::PublicKey::from_str(
+                "0355212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e2",
+            )
+            .unwrap(),
+        ];
+
+        let expected_out_agg_pk = secp256k1::PublicKey::from_str(
+            "0364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5",
+        )
+        .unwrap();
+
+        let expected_out_pubkeys = vec![
+            secp256k1::PublicKey::from_str(
+                "02841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b525",
+            )
+            .unwrap(),
+            secp256k1::PublicKey::from_str(
+                "02bad833849a98cdfb0a0749609ddccab16ad54485ecc67f828df4bdc4f2b90d4c",
+            )
+            .unwrap(),
+        ];
+
+        const PSBT_HEX: &str = "70736274ff01005e02000000017b42be5ea467afe0d0571dc4a91bef97ff9605a590c0b8d5892323946414d1810000000000ffffffff01f0b9f50500000000225120bc7e18f55e2c7a28d78cadac1bc72c248372375d269bafe6b315bc40505d07e5000000000001012b00e1f50500000000225120de564ebf8ff7bd9bb41bd88264c04b1713ebb9dc8df36319091d2eabb16cda6221161401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e000500eb4cbe62211655212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e20500755abbf92116bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a05002a33dfd90117201401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00221a021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e004202bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a0355212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e20001052064934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5210764934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba50500fa4c6afa22080364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba54202841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b52502bad833849a98cdfb0a0749609ddccab16ad54485ecc67f828df4bdc4f2b90d4c00";
+
+        let psbt = hex_psbt(PSBT_HEX).unwrap();
+
+        assert_eq!(psbt.inputs[0].musig2_participant_pubkeys.len(), 1);
+        assert_eq!(
+            psbt.inputs[0].musig2_participant_pubkeys.iter().next().unwrap(),
+            (&expected_in_agg_pk, &expected_in_pubkeys)
+        );
+
+        assert_eq!(psbt.outputs[0].musig2_participant_pubkeys.len(), 1);
+        assert_eq!(
+            psbt.outputs[0].musig2_participant_pubkeys.iter().next().unwrap(),
+            (&expected_out_agg_pk, &expected_out_pubkeys)
+        );
+
+        // Check round trip de/serialization
+        assert_eq!(psbt.serialize_hex(), PSBT_HEX);
+
+        const PSBT_TRUNCATED_MUSIG_PARTICIPANTS_HEX: &str = "70736274ff01005e0200000001f034711ce319b1db76ce73440f2cb64a7e3a02e75c936b8d8a4958a024ea8d870000000000ffffffff01f0b9f50500000000225120bc7e18f55e2c7a28d78cadac1bc72c248372375d269bafe6b315bc40505d07e5000000000001012b00e1f50500000000225120de564ebf8ff7bd9bb41bd88264c04b1713ebb9dc8df36319091d2eabb16cda6221161401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e000500eb4cbe62211655212dff7b3d7e8126687a62fd0435a3fb4de56d9af9ae23a1c9ca05b349c8e20500755abbf92116bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a05002a33dfd90117201401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e00221a021401301810a46a4e3f39e4603ec228ed301d9f2079767fda758dee7224b32e002a02bebd7a1cef20283444b96e9ce78137e951ce48705390933896311a9abc75736a0355212dff7b3d7e810001052064934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba5210764934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba50500fa4c6afa22080364934a64831bd917a2667b886671650846f021e1c025e4b2bb65e49ab3e7cba52a02841d69a8b80ae23a8090e6f3765540ea5efd8c287b1307c983a6e2a3a171b52502bad833849a98cdfb00";
+
+        hex_psbt(PSBT_TRUNCATED_MUSIG_PARTICIPANTS_HEX)
+            .expect_err("Deserializing PSBT with truncated musig participants should error");
+    }
+
     // PSBTs taken from BIP 174 test vectors.
     #[test]
     fn combine_psbts() {
@@ -2226,37 +2324,35 @@ mod tests {
         ));
     }
 
-    #[cfg(feature = "rand-std")]
-    fn gen_keys() -> (PrivateKey, PublicKey, Secp256k1<All>) {
-        use secp256k1::rand::thread_rng;
+    #[cfg(all(feature = "rand", feature = "std"))]
+    fn gen_keys() -> (PrivateKey, PublicKey) {
+        use secp256k1::rand;
 
-        let secp = Secp256k1::new();
-
-        let sk = SecretKey::new(&mut thread_rng());
+        let sk = SecretKey::new(&mut rand::rng());
         let priv_key = PrivateKey::new(sk, NetworkKind::Test);
-        let pk = PublicKey::from_private_key(&secp, priv_key);
+        let pk = PublicKey::from_private_key(priv_key);
 
-        (priv_key, pk, secp)
+        (priv_key, pk)
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn get_key_btree_map() {
-        let (priv_key, pk, secp) = gen_keys();
+        let (priv_key, pk) = gen_keys();
 
         let mut key_map = BTreeMap::new();
         key_map.insert(pk, priv_key);
 
-        let got = key_map.get_key(&KeyRequest::Pubkey(pk), &secp).expect("failed to get key");
+        let got = key_map.get_key(&KeyRequest::Pubkey(pk)).expect("failed to get key");
         assert_eq!(got.unwrap(), priv_key)
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn pubkey_map_get_key_negates_odd_parity_keys() {
         use crate::psbt::{GetKey, KeyRequest};
 
-        let (mut priv_key, mut pk, secp) = gen_keys();
+        let (mut priv_key, mut pk) = gen_keys();
         let (xonly, parity) = pk.inner.x_only_public_key();
 
         let mut pubkey_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
@@ -2267,16 +2363,16 @@ mod tests {
                 network: priv_key.network,
                 inner: priv_key.inner.negate(),
             };
-            pk = priv_key.public_key(&secp);
+            pk = priv_key.public_key();
         }
 
         pubkey_map.insert(pk, priv_key);
 
-        let req_result = pubkey_map.get_key(&KeyRequest::XOnlyPubkey(xonly.into()), &secp).unwrap();
+        let req_result = pubkey_map.get_key(&KeyRequest::XOnlyPubkey(xonly.into())).unwrap();
 
         let retrieved_key = req_result.unwrap();
 
-        let retrieved_pub_key = retrieved_key.public_key(&secp);
+        let retrieved_pub_key = retrieved_key.public_key();
         let (retrieved_xonly, retrieved_parity) = retrieved_pub_key.inner.x_only_public_key();
 
         assert_eq!(xonly, retrieved_xonly);
@@ -2287,6 +2383,23 @@ mod tests {
         );
     }
 
+    #[test]
+    fn get_key_xpriv_bip32_parent() {
+        let seed = hex!("000102030405060708090a0b0c0d0e0f");
+        let parent_xpriv: Xpriv = Xpriv::new_master(NetworkKind::Main, &seed);
+        let path: DerivationPath = "m/1/2/3".parse().unwrap();
+        let path_prefix: DerivationPath = "m/1".parse().unwrap();
+
+        let expected_private_key = parent_xpriv.derive_xpriv(&path).unwrap().to_private_key();
+
+        let derived_xpriv = parent_xpriv.derive_xpriv(&path_prefix).unwrap();
+
+        let derived_key =
+            derived_xpriv.get_key(&KeyRequest::Bip32((parent_xpriv.fingerprint(), path))).unwrap();
+
+        assert_eq!(derived_key, Some(expected_private_key));
+    }
+
     #[test]
     fn fee() {
         let output_0_val = Amount::from_sat_u32(99_999_699);
@@ -2297,7 +2410,7 @@ mod tests {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::from_consensus(1257139),
-                input: vec![
+                inputs: vec![
                     TxIn {
                         previous_output: OutPoint {
                             txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
@@ -2307,14 +2420,14 @@ mod tests {
                         ..TxIn::EMPTY_COINBASE
                     }
                 ],
-                output: vec![
+                outputs: vec![
                     TxOut {
-                        value: output_0_val,
-                        script_pubkey:  ScriptBuf::new()
+                        amount: output_0_val,
+                        script_pubkey: ScriptPubKeyBuf::new()
                     },
                     TxOut {
-                        value: output_1_val,
-                        script_pubkey:  ScriptBuf::new()
+                        amount: output_1_val,
+                        script_pubkey: ScriptPubKeyBuf::new()
                     },
                 ],
             },
@@ -2328,7 +2441,7 @@ mod tests {
                     non_witness_utxo: Some(Transaction {
                         version: transaction::Version::ONE,
                         lock_time: absolute::LockTime::ZERO,
-                        input: vec![
+                        inputs: vec![
                             TxIn {
                                 previous_output: OutPoint {
                                     txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
@@ -2346,14 +2459,14 @@ mod tests {
                                 ..TxIn::EMPTY_COINBASE
                             }
                         ],
-                        output: vec![
+                        outputs: vec![
                             TxOut {
-                                value: prev_output_val,
-                                script_pubkey:  ScriptBuf::new()
+                                amount: prev_output_val,
+                                script_pubkey:  ScriptPubKeyBuf::new()
                             },
                             TxOut {
-                                value: Amount::from_sat(190_303_501_938).unwrap(),
-                                script_pubkey:  ScriptBuf::new()
+                                amount: Amount::from_sat(190_303_501_938).unwrap(),
+                                script_pubkey:  ScriptPubKeyBuf::new()
                             },
                         ],
                     }),
@@ -2381,8 +2494,8 @@ mod tests {
             e => panic!("unexpected error: {:?}", e),
         }
         //  negative fee
-        let mut t3 = t.clone();
-        t3.unsigned_tx.output[0].value = prev_output_val;
+        let mut t3 = t;
+        t3.unsigned_tx.outputs[0].amount = prev_output_val;
         match t3.fee().unwrap_err() {
             Error::NegativeFee => {}
             e => panic!("unexpected error: {:?}", e),
@@ -2390,23 +2503,23 @@ mod tests {
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn hashmap_can_sign_taproot() {
-        let (priv_key, pk, secp) = gen_keys();
+        let (priv_key, pk) = gen_keys();
         let internal_key: XOnlyPublicKey = pk.inner.into();
 
         let tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: locktime::absolute::LockTime::ZERO,
-            input: vec![TxIn::EMPTY_COINBASE],
-            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
+            inputs: vec![TxIn::EMPTY_COINBASE],
+            outputs: vec![TxOut { amount: Amount::ZERO, script_pubkey: ScriptPubKeyBuf::new() }],
         };
 
         let mut psbt = Psbt::from_unsigned_tx(tx).unwrap();
         psbt.inputs[0].tap_internal_key = Some(internal_key);
         psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
-            value: Amount::from_sat_u32(10),
-            script_pubkey: ScriptBuf::new_p2tr(&secp, internal_key, None),
+            amount: Amount::from_sat_u32(10),
+            script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None),
         });
 
         let mut key_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
@@ -2417,29 +2530,29 @@ mod tests {
         tap_key_origins.insert(internal_key, (vec![], key_source));
         psbt.inputs[0].tap_key_origins = tap_key_origins;
 
-        let signing_keys = psbt.sign(&key_map, &secp).unwrap();
+        let signing_keys = psbt.sign(&key_map).unwrap();
         assert_eq!(signing_keys.len(), 1);
         assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn xonly_hashmap_can_sign_taproot() {
-        let (priv_key, pk, secp) = gen_keys();
+        let (priv_key, pk) = gen_keys();
         let internal_key: XOnlyPublicKey = pk.inner.into();
 
         let tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: locktime::absolute::LockTime::ZERO,
-            input: vec![TxIn::EMPTY_COINBASE],
-            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
+            inputs: vec![TxIn::EMPTY_COINBASE],
+            outputs: vec![TxOut { amount: Amount::ZERO, script_pubkey: ScriptPubKeyBuf::new() }],
         };
 
         let mut psbt = Psbt::from_unsigned_tx(tx).unwrap();
         psbt.inputs[0].tap_internal_key = Some(internal_key);
         psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
-            value: Amount::from_sat_u32(10),
-            script_pubkey: ScriptBuf::new_p2tr(&secp, internal_key, None),
+            amount: Amount::from_sat_u32(10),
+            script_pubkey: ScriptPubKeyBuf::new_p2tr(internal_key, None),
         });
 
         let mut xonly_key_map: HashMap<XOnlyPublicKey, PrivateKey> = HashMap::new();
@@ -2450,33 +2563,34 @@ mod tests {
         tap_key_origins.insert(internal_key, (vec![], key_source));
         psbt.inputs[0].tap_key_origins = tap_key_origins;
 
-        let signing_keys = psbt.sign(&xonly_key_map, &secp).unwrap();
+        let signing_keys = psbt.sign(&xonly_key_map).unwrap();
         assert_eq!(signing_keys.len(), 1);
         assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
     }
 
     #[test]
-    #[cfg(feature = "rand-std")]
+    #[cfg(all(feature = "rand", feature = "std"))]
     fn sign_psbt() {
         let unsigned_tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,
-            input: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
-            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
+            inputs: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
+
+            outputs: vec![TxOut { amount: Amount::ZERO, script_pubkey: ScriptPubKeyBuf::new() }],
         };
         let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).unwrap();
 
-        let (priv_key, pk, secp) = gen_keys();
+        let (priv_key, pk) = gen_keys();
 
         // key_map implements `GetKey` using KeyRequest::Pubkey. A pubkey key request does not use
-        // keysource so we use default `KeySource` (fingreprint and derivation path) below.
+        // keysource so we use default `KeySource` (fingerprint and derivation path) below.
         let mut key_map = BTreeMap::new();
         key_map.insert(pk, priv_key);
 
         // First input we can spend. See comment above on key_map for why we use defaults here.
         let txout_wpkh = TxOut {
-            value: Amount::from_sat_u32(10),
-            script_pubkey: ScriptBuf::new_p2wpkh(pk.wpubkey_hash().unwrap()),
+            amount: Amount::from_sat_u32(10),
+            script_pubkey: ScriptPubKeyBuf::new_p2wpkh(pk.wpubkey_hash().unwrap()),
         };
         psbt.inputs[0].witness_utxo = Some(txout_wpkh);
 
@@ -2487,12 +2601,12 @@ mod tests {
         // Second input is unspendable by us e.g., from another wallet that supports future upgrades.
         let unknown_prog = WitnessProgram::new(WitnessVersion::V4, &[0xaa; 34]).unwrap();
         let txout_unknown_future = TxOut {
-            value: Amount::from_sat_u32(10),
-            script_pubkey: ScriptBuf::new_witness_program(&unknown_prog),
+            amount: Amount::from_sat_u32(10),
+            script_pubkey: ScriptPubKeyBuf::new_witness_program(&unknown_prog),
         };
         psbt.inputs[1].witness_utxo = Some(txout_unknown_future);
 
-        let (signing_keys, _) = psbt.sign(&key_map, &secp).unwrap_err();
+        let (signing_keys, _) = psbt.sign(&key_map).unwrap_err();
 
         assert_eq!(signing_keys.len(), 1);
         assert_eq!(signing_keys[&0], SigningKeys::Ecdsa(vec![pk]));
diff --git a/bitcoin/src/psbt/raw.rs b/bitcoin/src/psbt/raw.rs
index 4502bde61f..91d50590ad 100644
--- a/bitcoin/src/psbt/raw.rs
+++ b/bitcoin/src/psbt/raw.rs
@@ -7,6 +7,8 @@
 
 use core::fmt;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 use internals::ToU64 as _;
 use io::{BufRead, Write};
 
@@ -21,25 +23,21 @@ use crate::psbt::Error;
 ///
 /// `<key> := <keylen> <keytype> <keydata>`
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Key {
     /// The type of this PSBT key.
     pub type_value: u64, // Encoded as a compact size.
     /// The key data itself in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key_data: Vec<u8>,
 }
 
 /// A PSBT key-value pair in its raw byte form.
 /// `<keypair> := <key> <value>`
 #[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Pair {
     /// The key of this key-value pair.
     pub key: Key,
     /// The value data of this key-value pair in raw byte form.
     /// `<value> := <valuelen> <valuedata>`
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub value: Vec<u8>,
 }
 
@@ -49,19 +47,16 @@ pub type ProprietaryType = u64;
 /// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
 /// structure according to BIP 174.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ProprietaryKey<Subtype = ProprietaryType>
 where
     Subtype: Copy + From<u64> + Into<u64>,
 {
     /// Proprietary type prefix used for grouping together keys under some
     /// application and avoid namespace collision
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub prefix: Vec<u8>,
     /// Custom proprietary subtype
     pub subtype: Subtype,
     /// Additional key bytes (like serialized public key data etc)
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key: Vec<u8>,
 }
 
@@ -96,7 +91,7 @@ impl Key {
             key_data.push(Decodable::consensus_decode(r)?);
         }
 
-        Ok(Key { type_value, key_data })
+        Ok(Self { type_value, key_data })
     }
 }
 
@@ -128,13 +123,13 @@ impl Serialize for Pair {
 impl Deserialize for Pair {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
         let mut decoder = bytes;
-        Pair::decode(&mut decoder)
+        Self::decode(&mut decoder)
     }
 }
 
 impl Pair {
     pub(crate) fn decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, Error> {
-        Ok(Pair { key: Key::decode(r)?, value: Decodable::consensus_decode(r)? })
+        Ok(Self { key: Key::decode(r)?, value: Decodable::consensus_decode(r)? })
     }
 }
 
@@ -162,9 +157,9 @@ where
         // The limit is a DOS protection mechanism the exact value is not
         // important, 1024 bytes is bigger than any key should be.
         let mut key = vec![];
-        let _ = r.read_to_limit(&mut key, 1024)?;
+        let _ = io::Read::read_to_limit(r, &mut key, 1024)?;
 
-        Ok(ProprietaryKey { prefix, subtype, key })
+        Ok(Self { prefix, subtype, key })
     }
 }
 
@@ -195,3 +190,21 @@ where
         Ok(deserialize(&key.key_data)?)
     }
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for ProprietaryKey {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            prefix: Vec::<u8>::arbitrary(u)?,
+            subtype: u64::arbitrary(u)?,
+            key: Vec::<u8>::arbitrary(u)?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Key {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { type_value: u.arbitrary()?, key_data: Vec::<u8>::arbitrary(u)? })
+    }
+}
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 8f6193fd2d..8d68df88f7 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -3,7 +3,7 @@
 //! PSBT serialization.
 //!
 //! Traits to serialize PSBT values to and from raw bytes
-//! according to the BIP-174 specification.
+//! according to the BIP-0174 specification.
 
 use hashes::{hash160, ripemd160, sha256, sha256d};
 use internals::compact_size;
@@ -28,28 +28,28 @@ use crate::witness::Witness;
 /// A trait for serializing a value as raw data for insertion into PSBT
 /// key-value maps.
 pub(crate) trait Serialize {
-    /// Serialize a value as raw data.
+    /// Serializes a value as raw data.
     fn serialize(&self) -> Vec<u8>;
 }
 
 /// A trait for deserializing a value from raw data in PSBT key-value maps.
 pub(crate) trait Deserialize: Sized {
-    /// Deserialize a value from raw data.
+    /// Deserializes a value from raw data.
     fn deserialize(bytes: &[u8]) -> Result<Self, Error>;
 }
 
 impl Psbt {
-    /// Serialize a value as bytes in hex.
+    /// Serializes a value as bytes in hex.
     pub fn serialize_hex(&self) -> String { self.serialize().to_lower_hex_string() }
 
-    /// Serialize as raw binary data
+    /// Serializes as raw binary data
     pub fn serialize(&self) -> Vec<u8> {
         let mut buf: Vec<u8> = Vec::new();
         self.serialize_to_writer(&mut buf).expect("Writing to Vec can't fail");
         buf
     }
 
-    /// Serialize the PSBT into a writer.
+    /// Serializes the PSBT into a writer.
     pub fn serialize_to_writer(&self, w: &mut impl Write) -> io::Result<usize> {
         let mut written_len = 0;
 
@@ -75,12 +75,12 @@ impl Psbt {
         Ok(written_len)
     }
 
-    /// Deserialize a value from raw binary data.
+    /// Deserializes a value from raw binary data.
     pub fn deserialize(mut bytes: &[u8]) -> Result<Self, Error> {
         Self::deserialize_from_reader(&mut bytes)
     }
 
-    /// Deserialize a value from raw binary data read from a `BufRead` object.
+    /// Deserializes a value from raw binary data read from a `BufRead` object.
     pub fn deserialize_from_reader<R: io::BufRead>(r: &mut R) -> Result<Self, Error> {
         const MAGIC_BYTES: &[u8] = b"psbt";
 
@@ -89,29 +89,41 @@ impl Psbt {
             return Err(Error::InvalidMagic);
         }
 
-        const PSBT_SERPARATOR: u8 = 0xff_u8;
+        const PSBT_SEPARATOR: u8 = 0xff_u8;
         let separator: u8 = Decodable::consensus_decode(r)?;
-        if separator != PSBT_SERPARATOR {
+        if separator != PSBT_SEPARATOR {
             return Err(Error::InvalidSeparator);
         }
 
-        let mut global = Psbt::decode_global(r)?;
+        let mut global = Self::decode_global(r)?;
         global.unsigned_tx_checks()?;
 
         let inputs: Vec<Input> = {
-            let inputs_len: usize = (global.unsigned_tx.input).len();
+            let inputs_len: usize = (global.unsigned_tx.inputs).len();
 
             let mut inputs: Vec<Input> = Vec::with_capacity(inputs_len);
 
-            for _ in 0..inputs_len {
-                inputs.push(Input::decode(r)?);
+            for i in 0..inputs_len {
+                let input = Input::decode(r)?;
+                if let Some(ref tx) = input.non_witness_utxo {
+                    let input_outpoint = global.unsigned_tx.inputs[i].previous_output;
+                    let txid = tx.compute_txid();
+                    if txid != input_outpoint.txid {
+                        return Err(Error::IncorrectNonWitnessUtxo {
+                            index: i,
+                            input_outpoint,
+                            non_witness_utxo_txid: txid,
+                        });
+                    }
+                }
+                inputs.push(input);
             }
 
             inputs
         };
 
         let outputs: Vec<Output> = {
-            let outputs_len: usize = (global.unsigned_tx.output).len();
+            let outputs_len: usize = (global.unsigned_tx.outputs).len();
 
             let mut outputs: Vec<Output> = Vec::with_capacity(outputs_len);
 
@@ -140,11 +152,11 @@ impl_psbt_hash_de_serialize!(sha256d::Hash);
 // Taproot
 impl_psbt_de_serialize!(Vec<TapLeafHash>);
 
-impl Serialize for ScriptBuf {
+impl<T> Serialize for ScriptBuf<T> {
     fn serialize(&self) -> Vec<u8> { self.to_vec() }
 }
 
-impl Deserialize for ScriptBuf {
+impl<T> Deserialize for ScriptBuf<T> {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> { Ok(Self::from(bytes.to_vec())) }
 }
 
@@ -158,7 +170,7 @@ impl Serialize for PublicKey {
 
 impl Deserialize for PublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        PublicKey::from_slice(bytes).map_err(Error::InvalidPublicKey)
+        Self::from_slice(bytes).map_err(Error::InvalidPublicKey)
     }
 }
 
@@ -168,7 +180,29 @@ impl Serialize for secp256k1::PublicKey {
 
 impl Deserialize for secp256k1::PublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        secp256k1::PublicKey::from_slice(bytes).map_err(Error::InvalidSecp256k1PublicKey)
+        Self::from_slice(bytes).map_err(Error::InvalidSecp256k1PublicKey)
+    }
+}
+
+impl Serialize for Vec<secp256k1::PublicKey> {
+    fn serialize(&self) -> Vec<u8> {
+        let mut result: Vec<u8> =
+            Vec::with_capacity(secp256k1::constants::PUBLIC_KEY_SIZE * self.len());
+
+        for pubkey in self.iter() {
+            result.extend(Serialize::serialize(pubkey));
+        }
+
+        result
+    }
+}
+
+impl Deserialize for Vec<secp256k1::PublicKey> {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        bytes
+            .chunks(secp256k1::constants::PUBLIC_KEY_SIZE)
+            .map(secp256k1::PublicKey::deserialize)
+            .collect()
     }
 }
 
@@ -178,7 +212,7 @@ impl Serialize for ecdsa::Signature {
 
 impl Deserialize for ecdsa::Signature {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        // NB: Since BIP-174 says "the signature as would be pushed to the stack from
+        // NB: Since BIP-0174 says "the signature as would be pushed to the stack from
         // a scriptSig or witness" we should ideally use a consensus deserialization and do
         // not error on a non-standard values. However,
         //
@@ -188,10 +222,10 @@ impl Deserialize for ecdsa::Signature {
         // EcdsaSig::from_slice(&sl[..]).to_vec = sl.
         //
         // 2) This would cause to have invalid signatures because the sighash message
-        // also has a field sighash_u32 (See BIP141). For example, when signing with non-standard
+        // also has a field sighash_u32 (See BIP-0141). For example, when signing with non-standard
         // 0x05, the sighash message would have the last field as 0x05u32 while, the verification
-        // would use check the signature assuming sighash_u32 as `0x01`.
-        ecdsa::Signature::from_slice(bytes).map_err(|e| match e {
+        // would check the signature assuming sighash_u32 as `0x01`.
+        Self::from_slice(bytes).map_err(|e| match e {
             ecdsa::DecodeError::EmptySignature => Error::InvalidEcdsaSignature(e),
             ecdsa::DecodeError::SighashType(err) => Error::NonStandardSighashType(err.0),
             ecdsa::DecodeError::Secp256k1(..) => Error::InvalidEcdsaSignature(e),
@@ -248,18 +282,18 @@ impl Serialize for PsbtSighashType {
 impl Deserialize for PsbtSighashType {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
         let raw: u32 = encode::deserialize(bytes)?;
-        Ok(PsbtSighashType { inner: raw })
+        Ok(Self { inner: raw })
     }
 }
 
 // Taproot related ser/deser
 impl Serialize for XOnlyPublicKey {
-    fn serialize(&self) -> Vec<u8> { XOnlyPublicKey::serialize(self).to_vec() }
+    fn serialize(&self) -> Vec<u8> { Self::serialize(self).to_vec() }
 }
 
 impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        XOnlyPublicKey::from_byte_array(bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?)
+        Self::from_byte_array(bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?)
             .map_err(|_| Error::InvalidXOnlyPublicKey)
     }
 }
@@ -270,12 +304,11 @@ impl Serialize for taproot::Signature {
 
 impl Deserialize for taproot::Signature {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        use taproot::SigFromSliceError::*;
-
-        taproot::Signature::from_slice(bytes).map_err(|e| match e {
-            SighashType(err) => Error::NonStandardSighashType(err.0),
-            InvalidSignatureSize(_) => Error::InvalidTaprootSignature(e),
-            Secp256k1(..) => Error::InvalidTaprootSignature(e),
+        Self::from_slice(bytes).map_err(|e| match e {
+            taproot::SigFromSliceError::SighashType(err) => Error::NonStandardSighashType(err.0),
+            taproot::SigFromSliceError::InvalidSignatureSize(_) =>
+                Error::InvalidTaprootSignature(e),
+            taproot::SigFromSliceError::Secp256k1(..) => Error::InvalidTaprootSignature(e),
         })
     }
 }
@@ -302,7 +335,7 @@ impl Deserialize for (XOnlyPublicKey, TapLeafHash) {
 }
 
 impl Serialize for ControlBlock {
-    fn serialize(&self) -> Vec<u8> { ControlBlock::serialize(self) }
+    fn serialize(&self) -> Vec<u8> { Self::serialize(self) }
 }
 
 impl Deserialize for ControlBlock {
@@ -312,7 +345,7 @@ impl Deserialize for ControlBlock {
 }
 
 // Versioned ScriptBuf
-impl Serialize for (ScriptBuf, LeafVersion) {
+impl<T> Serialize for (ScriptBuf<T>, LeafVersion) {
     fn serialize(&self) -> Vec<u8> {
         let mut buf = Vec::with_capacity(self.0.len() + 1);
         buf.extend(self.0.as_bytes());
@@ -321,7 +354,7 @@ impl Serialize for (ScriptBuf, LeafVersion) {
     }
 }
 
-impl Deserialize for (ScriptBuf, LeafVersion) {
+impl<T> Deserialize for (ScriptBuf<T>, LeafVersion) {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
         if bytes.is_empty() {
             return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
@@ -381,7 +414,7 @@ impl Deserialize for TapTree {
         let mut bytes_iter = bytes.iter();
         while let Some(depth) = bytes_iter.next() {
             let version = bytes_iter.next().ok_or(Error::Taproot("invalid Taproot Builder"))?;
-            let (script, consumed) = deserialize_partial::<ScriptBuf>(bytes_iter.as_slice())?;
+            let (script, consumed) = deserialize_partial::<ScriptBuf<_>>(bytes_iter.as_slice())?;
             if consumed > 0 {
                 bytes_iter.nth(consumed - 1);
             }
@@ -391,7 +424,7 @@ impl Deserialize for TapTree {
                 .add_leaf_with_ver(*depth, script, leaf_version)
                 .map_err(|_| Error::Taproot("Tree not in DFS order"))?;
         }
-        TapTree::try_from(builder).map_err(Error::TapTree)
+        Self::try_from(builder).map_err(Error::TapTree)
     }
 }
 
@@ -402,8 +435,9 @@ fn key_source_len(key_source: &KeySource) -> usize { 4 + 4 * (key_source.1).as_r
 mod tests {
     use super::*;
     use crate::script::ScriptBufExt as _;
+    use crate::TapScriptBuf;
 
-    // Composes tree matching a given depth map, filled with dumb script leafs,
+    // Composes tree matching a given depth map, filled with dumb script leaves,
     // each of which consists of a single push-int op code, with int value
     // increased for each consecutive leaf.
     pub fn compose_taproot_builder<'map>(
@@ -413,7 +447,7 @@ mod tests {
         let mut val = opcode;
         let mut builder = TaprootBuilder::new();
         for depth in depth_map {
-            let script = ScriptBuf::from_hex_no_length_prefix(&format!("{:02x}", val)).unwrap();
+            let script = TapScriptBuf::from_hex_no_length_prefix(&format!("{:02x}", val)).unwrap();
             builder = builder.add_leaf(*depth, script).unwrap();
             let (new_val, _) = val.overflowing_add(1);
             val = new_val;
@@ -428,7 +462,7 @@ mod tests {
         builder = builder
             .add_leaf_with_ver(
                 3,
-                ScriptBuf::from_hex_no_length_prefix("b9").unwrap(),
+                TapScriptBuf::from_hex_no_length_prefix("b9").unwrap(),
                 LeafVersion::from_consensus(0xC2).unwrap(),
             )
             .unwrap();
@@ -442,7 +476,7 @@ mod tests {
         builder = builder
             .add_leaf_with_ver(
                 3,
-                ScriptBuf::from_hex_no_length_prefix("b9").unwrap(),
+                TapScriptBuf::from_hex_no_length_prefix("b9").unwrap(),
                 LeafVersion::from_consensus(0xC2).unwrap(),
             )
             .unwrap();
diff --git a/bitcoin/src/serde_utils.rs b/bitcoin/src/serde_utils.rs
deleted file mode 100644
index df306d9df5..0000000000
--- a/bitcoin/src/serde_utils.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin serde utilities.
-//!
-//! This module is for special serde serializations.
-
-pub(crate) struct SerializeBytesAsHex<'a>(pub(crate) &'a [u8]);
-
-impl serde::Serialize for SerializeBytesAsHex<'_> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use hex::DisplayHex;
-
-        serializer.collect_str(&format_args!("{:x}", self.0.as_hex()))
-    }
-}
-
-pub mod btreemap_byte_values {
-    //! Module for serialization of BTreeMaps with hex byte values.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use hex::FromHex;
-
-    use crate::prelude::{BTreeMap, Vec};
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-        T: serde::Serialize + core::hash::Hash + Eq + Ord,
-    {
-        use serde::ser::SerializeMap;
-
-        // Don't do anything special when not human readable.
-        if !s.is_human_readable() {
-            serde::Serialize::serialize(v, s)
-        } else {
-            let mut map = s.serialize_map(Some(v.len()))?;
-            for (key, value) in v.iter() {
-                map.serialize_entry(key, &super::SerializeBytesAsHex(value))?;
-            }
-            map.end()
-        }
-    }
-
-    pub fn deserialize<'de, D, T>(d: D) -> Result<BTreeMap<T, Vec<u8>>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-    {
-        use core::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
-        where
-            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                write!(f, "a map with hexadecimal values")
-            }
-
-            fn visit_map<A: serde::de::MapAccess<'de>>(
-                self,
-                mut a: A,
-            ) -> Result<Self::Value, A::Error> {
-                let mut ret = BTreeMap::new();
-                while let Some((key, value)) = a.next_entry()? {
-                    ret.insert(key, FromHex::from_hex(value).map_err(serde::de::Error::custom)?);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if !d.is_human_readable() {
-            serde::Deserialize::deserialize(d)
-        } else {
-            d.deserialize_map(Visitor(PhantomData))
-        }
-    }
-}
-
-pub mod btreemap_as_seq {
-    //! Module for serialization of BTreeMaps as lists of sequences because
-    //! serde_json will not serialize hashmaps with non-string keys be default.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use crate::prelude::BTreeMap;
-
-    pub fn serialize<S, T, U>(v: &BTreeMap<T, U>, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-        T: serde::Serialize + core::hash::Hash + Eq + Ord,
-        U: serde::Serialize,
-    {
-        use serde::ser::SerializeSeq;
-
-        // Don't do anything special when not human readable.
-        if !s.is_human_readable() {
-            serde::Serialize::serialize(v, s)
-        } else {
-            let mut seq = s.serialize_seq(Some(v.len()))?;
-            for pair in v.iter() {
-                seq.serialize_element(&pair)?;
-            }
-            seq.end()
-        }
-    }
-
-    pub fn deserialize<'de, D, T, U>(d: D) -> Result<BTreeMap<T, U>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-        U: serde::Deserialize<'de>,
-    {
-        use core::marker::PhantomData;
-
-        struct Visitor<T, U>(PhantomData<(T, U)>);
-        impl<'de, T, U> serde::de::Visitor<'de> for Visitor<T, U>
-        where
-            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-            U: serde::Deserialize<'de>,
-        {
-            type Value = BTreeMap<T, U>;
-
-            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                write!(f, "a sequence of pairs")
-            }
-
-            fn visit_seq<A: serde::de::SeqAccess<'de>>(
-                self,
-                mut a: A,
-            ) -> Result<Self::Value, A::Error> {
-                let mut ret = BTreeMap::new();
-                while let Some((key, value)) = a.next_element()? {
-                    ret.insert(key, value);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if !d.is_human_readable() {
-            serde::Deserialize::deserialize(d)
-        } else {
-            d.deserialize_seq(Visitor(PhantomData))
-        }
-    }
-}
-
-pub mod btreemap_as_seq_byte_values {
-    //! Module for serialization of BTreeMaps as lists of sequences because
-    //! serde_json will not serialize hashmaps with non-string keys be default.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use crate::prelude::{BTreeMap, Vec};
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Deserialize)]
-    struct OwnedPair<T>(
-        T,
-        #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")] Vec<u8>,
-    );
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Serialize)]
-    struct BorrowedPair<'a, T: 'static>(
-        &'a T,
-        #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")] &'a [u8],
-    );
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-        T: serde::Serialize + core::hash::Hash + Eq + Ord + 'static,
-    {
-        use serde::ser::SerializeSeq;
-
-        // Don't do anything special when not human readable.
-        if !s.is_human_readable() {
-            serde::Serialize::serialize(v, s)
-        } else {
-            let mut seq = s.serialize_seq(Some(v.len()))?;
-            for (key, value) in v.iter() {
-                seq.serialize_element(&BorrowedPair(key, value))?;
-            }
-            seq.end()
-        }
-    }
-
-    pub fn deserialize<'de, D, T>(d: D) -> Result<BTreeMap<T, Vec<u8>>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-    {
-        use core::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
-        where
-            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                write!(f, "a sequence of pairs")
-            }
-
-            fn visit_seq<A: serde::de::SeqAccess<'de>>(
-                self,
-                mut a: A,
-            ) -> Result<Self::Value, A::Error> {
-                let mut ret = BTreeMap::new();
-                while let Option::Some(OwnedPair(key, value)) = a.next_element()? {
-                    ret.insert(key, value);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if !d.is_human_readable() {
-            serde::Deserialize::deserialize(d)
-        } else {
-            d.deserialize_seq(Visitor(PhantomData))
-        }
-    }
-}
-
-pub mod hex_bytes {
-    //! Module for serialization of byte arrays as hex strings.
-    #![allow(missing_docs)]
-
-    use hex::FromHex;
-
-    pub fn serialize<T, S>(bytes: &T, s: S) -> Result<S::Ok, S::Error>
-    where
-        T: serde::Serialize + AsRef<[u8]>,
-        S: serde::Serializer,
-    {
-        // Don't do anything special when not human readable.
-        if !s.is_human_readable() {
-            serde::Serialize::serialize(bytes, s)
-        } else {
-            serde::Serialize::serialize(&super::SerializeBytesAsHex(bytes.as_ref()), s)
-        }
-    }
-
-    pub fn deserialize<'de, D, B>(d: D) -> Result<B, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-        B: serde::Deserialize<'de> + FromHex,
-    {
-        struct Visitor<B>(core::marker::PhantomData<B>);
-
-        impl<B: FromHex> serde::de::Visitor<'_> for Visitor<B> {
-            type Value = B;
-
-            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
-                formatter.write_str("an ASCII hex string")
-            }
-
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                if let Ok(hex) = core::str::from_utf8(v) {
-                    FromHex::from_hex(hex).map_err(E::custom)
-                } else {
-                    Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self))
-                }
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                FromHex::from_hex(v).map_err(E::custom)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if !d.is_human_readable() {
-            serde::Deserialize::deserialize(d)
-        } else {
-            d.deserialize_str(Visitor(core::marker::PhantomData))
-        }
-    }
-}
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index d5f2be8481..57bca879c2 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -51,13 +51,11 @@ mod message_signing {
 
     impl fmt::Display for MessageSignatureError {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            use MessageSignatureError::*;
-
-            match *self {
-                InvalidLength => write!(f, "length not 65 bytes"),
-                InvalidEncoding(ref e) => write_err!(f, "invalid encoding"; e),
-                InvalidBase64 => write!(f, "invalid base64"),
-                UnsupportedAddressType(ref address_type) =>
+            match self {
+                Self::InvalidLength => write!(f, "length not 65 bytes"),
+                Self::InvalidEncoding(ref e) => write_err!(f, "invalid encoding"; e),
+                Self::InvalidBase64 => write!(f, "invalid base64"),
+                Self::UnsupportedAddressType(ref address_type) =>
                     write!(f, "unsupported address type: {}", address_type),
             }
         }
@@ -66,19 +64,15 @@ mod message_signing {
     #[cfg(feature = "std")]
     impl std::error::Error for MessageSignatureError {
         fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-            use MessageSignatureError::*;
-
-            match *self {
-                InvalidEncoding(ref e) => Some(e),
-                InvalidLength | InvalidBase64 | UnsupportedAddressType(_) => None,
+            match self {
+                Self::InvalidEncoding(ref e) => Some(e),
+                Self::InvalidLength | Self::InvalidBase64 | Self::UnsupportedAddressType(_) => None,
             }
         }
     }
 
     impl From<secp256k1::Error> for MessageSignatureError {
-        fn from(e: secp256k1::Error) -> MessageSignatureError {
-            MessageSignatureError::InvalidEncoding(e)
-        }
+        fn from(e: secp256k1::Error) -> Self { Self::InvalidEncoding(e) }
     }
 
     /// A signature on a Bitcoin Signed Message.
@@ -96,27 +90,27 @@ mod message_signing {
 
     impl MessageSignature {
         /// Constructs a new [MessageSignature].
-        pub fn new(signature: RecoverableSignature, compressed: bool) -> MessageSignature {
-            MessageSignature { signature, compressed }
+        pub fn new(signature: RecoverableSignature, compressed: bool) -> Self {
+            Self { signature, compressed }
         }
 
-        /// Serialize to bytes.
+        /// Serializes to bytes.
         pub fn serialize(&self) -> [u8; 65] {
             let (recid, raw) = self.signature.serialize_compact();
             let mut serialized = [0u8; 65];
-            serialized[0] = i32::from(recid) as u8 + if self.compressed { 31 } else { 27 };
+            serialized[0] = recid.to_u8() + if self.compressed { 31 } else { 27 };
             serialized[1..].copy_from_slice(&raw[..]);
             serialized
         }
 
         /// Constructs a new `MessageSignature` from a fixed-length array.
-        pub fn from_byte_array(bytes: &[u8; 65]) -> Result<MessageSignature, secp256k1::Error> {
+        pub fn from_byte_array(bytes: &[u8; 65]) -> Result<Self, secp256k1::Error> {
             // We just check this here so we can safely subtract further.
             if bytes[0] < 27 {
                 return Err(secp256k1::Error::InvalidRecoveryId);
             };
             let recid = RecoveryId::try_from(((bytes[0] - 27) & 0x03) as i32)?;
-            Ok(MessageSignature {
+            Ok(Self {
                 signature: RecoverableSignature::from_compact(&bytes[1..], recid)?,
                 compressed: ((bytes[0] - 27) & 0x04) != 0,
             })
@@ -124,7 +118,7 @@ mod message_signing {
 
         /// Constructs a new `MessageSignature` from a byte slice.
         #[deprecated(since = "TBD", note = "use `from_byte_array` instead")]
-        pub fn from_slice(bytes: &[u8]) -> Result<MessageSignature, MessageSignatureError> {
+        pub fn from_slice(bytes: &[u8]) -> Result<Self, MessageSignatureError> {
             let byte_array: [u8; 65] =
                 bytes.try_into().map_err(|_| MessageSignatureError::InvalidLength)?;
             Self::from_byte_array(&byte_array).map_err(MessageSignatureError::from)
@@ -133,28 +127,26 @@ mod message_signing {
         /// Attempt to recover a public key from the signature and the signed message.
         ///
         /// To get the message hash from a message, use [super::signed_msg_hash].
-        pub fn recover_pubkey<C: secp256k1::Verification>(
+        pub fn recover_pubkey(
             &self,
-            secp_ctx: &secp256k1::Secp256k1<C>,
             msg_hash: sha256d::Hash,
         ) -> Result<PublicKey, MessageSignatureError> {
             let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
-            let pubkey = secp_ctx.recover_ecdsa(&msg, &self.signature)?;
+            let pubkey = self.signature.recover_ecdsa(msg)?;
             Ok(PublicKey { inner: pubkey, compressed: self.compressed })
         }
 
-        /// Verify that the signature signs the message and was signed by the given address.
+        /// Verifies that the signature signs the message and was signed by the given address.
         ///
         /// To get the message hash from a message, use [super::signed_msg_hash].
-        pub fn is_signed_by_address<C: secp256k1::Verification>(
+        pub fn is_signed_by_address(
             &self,
-            secp_ctx: &secp256k1::Secp256k1<C>,
             address: &Address,
             msg_hash: sha256d::Hash,
         ) -> Result<bool, MessageSignatureError> {
             match address.address_type() {
                 Some(AddressType::P2pkh) => {
-                    let pubkey = self.recover_pubkey(secp_ctx, msg_hash)?;
+                    let pubkey = self.recover_pubkey(msg_hash)?;
                     Ok(address.pubkey_hash() == Some(pubkey.pubkey_hash()))
                 }
                 Some(address_type) =>
@@ -172,8 +164,8 @@ mod message_signing {
         use crate::prelude::String;
 
         impl MessageSignature {
-            /// Convert a signature from base64 encoding.
-            pub fn from_base64(s: &str) -> Result<MessageSignature, MessageSignatureError> {
+            /// Converts a signature from base64 encoding.
+            pub fn from_base64(s: &str) -> Result<Self, MessageSignatureError> {
                 if s.len() != 88 {
                     return Err(MessageSignatureError::InvalidLength);
                 }
@@ -181,10 +173,10 @@ mod message_signing {
                 BASE64_STANDARD
                     .decode_slice_unchecked(s, &mut byte_array)
                     .map_err(|_| MessageSignatureError::InvalidBase64)?;
-                MessageSignature::from_byte_array(&byte_array).map_err(MessageSignatureError::from)
+                Self::from_byte_array(&byte_array).map_err(MessageSignatureError::from)
             }
 
-            /// Convert to base64 encoding.
+            /// Converts to base64 encoding.
             pub fn to_base64(self) -> String { BASE64_STANDARD.encode(self.serialize()) }
         }
 
@@ -198,9 +190,7 @@ mod message_signing {
 
         impl core::str::FromStr for MessageSignature {
             type Err = MessageSignatureError;
-            fn from_str(s: &str) -> Result<MessageSignature, MessageSignatureError> {
-                MessageSignature::from_base64(s)
-            }
+            fn from_str(s: &str) -> Result<Self, MessageSignatureError> { Self::from_base64(s) }
         }
     }
 }
@@ -217,14 +207,12 @@ pub fn signed_msg_hash(msg: impl AsRef<[u8]>) -> sha256d::Hash {
 
 /// Sign message using Bitcoin's message signing format.
 #[cfg(feature = "secp-recovery")]
-pub fn sign<C: secp256k1::Signing>(
-    secp_ctx: &secp256k1::Secp256k1<C>,
-    msg: impl AsRef<[u8]>,
-    privkey: SecretKey,
-) -> MessageSignature {
+pub fn sign(msg: impl AsRef<[u8]>, privkey: SecretKey) -> MessageSignature {
+    use secp256k1::ecdsa::RecoverableSignature;
+
     let msg_hash = signed_msg_hash(msg);
     let msg_to_sign = secp256k1::Message::from_digest(msg_hash.to_byte_array());
-    let secp_sig = secp_ctx.sign_ecdsa_recoverable(&msg_to_sign, &privkey);
+    let secp_sig = RecoverableSignature::sign_ecdsa_recoverable(msg_to_sign, &privkey);
     MessageSignature { signature: secp_sig, compressed: true }
 }
 
@@ -242,45 +230,44 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand-std"))]
+    #[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand", feature = "std"))]
     fn message_signature() {
-        use secp256k1;
+        use secp256k1::ecdsa::RecoverableSignature;
 
         use crate::{Address, AddressType, Network, NetworkKind};
 
-        let secp = secp256k1::Secp256k1::new();
         let message = "rust-bitcoin MessageSignature test";
         let msg_hash = super::signed_msg_hash(message);
         let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
-        let privkey = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
-        let secp_sig = secp.sign_ecdsa_recoverable(&msg, &privkey);
+        let privkey = secp256k1::SecretKey::new(&mut secp256k1::rand::rng());
+        let secp_sig = RecoverableSignature::sign_ecdsa_recoverable(msg, &privkey);
         let signature = super::MessageSignature { signature: secp_sig, compressed: true };
 
-        assert_eq!(signature.to_string(), super::sign(&secp, message, privkey).to_string());
+        assert_eq!(signature.to_string(), super::sign(message, privkey).to_string());
         assert_eq!(signature.to_base64(), signature.to_string());
         let signature2 = &signature.to_string().parse::<super::MessageSignature>().unwrap();
         let pubkey = signature2
-            .recover_pubkey(&secp, msg_hash)
+            .recover_pubkey(msg_hash)
             .unwrap()
             .try_into()
             .expect("compressed was set to true");
 
         let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
-        assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
+        assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
         let p2wpkh = Address::p2wpkh(pubkey, Network::Bitcoin);
         assert_eq!(
-            signature2.is_signed_by_address(&secp, &p2wpkh, msg_hash),
+            signature2.is_signed_by_address(&p2wpkh, msg_hash),
             Err(MessageSignatureError::UnsupportedAddressType(AddressType::P2wpkh))
         );
         let p2shwpkh = Address::p2shwpkh(pubkey, NetworkKind::Main);
         assert_eq!(
-            signature2.is_signed_by_address(&secp, &p2shwpkh, msg_hash),
+            signature2.is_signed_by_address(&p2shwpkh, msg_hash),
             Err(MessageSignatureError::UnsupportedAddressType(AddressType::P2sh))
         );
         let p2pkh = Address::p2pkh(pubkey, Network::Bitcoin);
-        assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
+        assert_eq!(signature2.is_signed_by_address(&p2pkh, msg_hash), Ok(true));
 
-        assert_eq!(pubkey.0, secp256k1::PublicKey::from_secret_key(&secp, &privkey));
+        assert_eq!(pubkey.0, secp256k1::PublicKey::from_secret_key(&privkey));
         let signature_base64 = signature.to_base64();
         let signature_round_trip =
             super::MessageSignature::from_base64(&signature_base64).expect("message signature");
@@ -291,12 +278,10 @@ mod tests {
     #[cfg(all(feature = "secp-recovery", feature = "base64"))]
     fn incorrect_message_signature() {
         use base64::prelude::{Engine as _, BASE64_STANDARD};
-        use secp256k1;
 
         use crate::crypto::key::PublicKey;
         use crate::{Address, NetworkKind};
 
-        let secp = secp256k1::Secp256k1::new();
         let message = "a different message from what was signed";
         let msg_hash = super::signed_msg_hash(message);
 
@@ -312,6 +297,6 @@ mod tests {
                 .expect("pubkey slice");
 
         let p2pkh = Address::p2pkh(pubkey, NetworkKind::Main);
-        assert_eq!(signature.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(false));
+        assert_eq!(signature.is_signed_by_address(&p2pkh, msg_hash), Ok(false));
     }
 }
diff --git a/bitcoin/src/taproot/merkle_branch/borrowed.rs b/bitcoin/src/taproot/merkle_branch/borrowed.rs
index 85a839db60..dea3a5ddf5 100644
--- a/bitcoin/src/taproot/merkle_branch/borrowed.rs
+++ b/bitcoin/src/taproot/merkle_branch/borrowed.rs
@@ -1,4 +1,5 @@
 use core::borrow::{Borrow, BorrowMut};
+use core::slice;
 
 use internals::slice::SliceExt;
 pub use privacy_boundary::TaprootMerkleBranch;
@@ -46,11 +47,11 @@ impl TaprootMerkleBranch {
     #[inline]
     pub fn is_empty(&self) -> bool { self.as_slice().is_empty() }
 
-    /// Creates an iterator over the node hashes.
+    /// Constructs an iterator over the node hashes.
     #[inline]
     pub fn iter(&self) -> core::slice::Iter<'_, TapNodeHash> { self.into_iter() }
 
-    /// Creates an iterator over the mutable node hashes.
+    /// Constructs an iterator over the mutable node hashes.
     #[inline]
     pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, TapNodeHash> { self.into_iter() }
 
@@ -95,11 +96,11 @@ impl TaprootMerkleBranch {
     fn decode_exact(
         nodes: &[[u8; TAPROOT_CONTROL_NODE_SIZE]],
     ) -> Result<&Self, InvalidMerkleTreeDepthError> {
-        // SAFETY:
-        // The lifetime of the returned reference is the same as the lifetime of the input
-        // reference, the size of `TapNodeHash` is equal to `TAPROOT_CONTROL_NODE_SIZE` and the
-        // alignment of `TapNodeHash` is equal to the alignment of `u8` (see tests below).
-        Self::from_hashes(unsafe { &*(nodes as *const _ as *const [TapNodeHash]) })
+        // SAFETY: `TapNodeHash` is `#[repr(transparent)]` and contains a (type which is
+        // `#[repr(transparent)]` and contains a) `[u8; 32]`.
+        Self::from_hashes(unsafe {
+            slice::from_raw_parts(nodes.as_ptr().cast::<TapNodeHash>(), nodes.len())
+        })
     }
 
     fn from_hashes(nodes: &[TapNodeHash]) -> Result<&Self, InvalidMerkleTreeDepthError> {
@@ -115,12 +116,12 @@ impl Default for &'_ TaprootMerkleBranch {
     fn default() -> Self { TaprootMerkleBranch::new() }
 }
 
-impl AsRef<TaprootMerkleBranch> for TaprootMerkleBranch {
-    fn as_ref(&self) -> &TaprootMerkleBranch { self }
+impl AsRef<Self> for TaprootMerkleBranch {
+    fn as_ref(&self) -> &Self { self }
 }
 
-impl AsMut<TaprootMerkleBranch> for TaprootMerkleBranch {
-    fn as_mut(&mut self) -> &mut TaprootMerkleBranch { self }
+impl AsMut<Self> for TaprootMerkleBranch {
+    fn as_mut(&mut self) -> &mut Self { self }
 }
 
 impl AsRef<TaprootMerkleBranch> for TaprootMerkleBranchBuf {
diff --git a/bitcoin/src/taproot/merkle_branch/buf.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
index 11b2850c45..4655b604b4 100644
--- a/bitcoin/src/taproot/merkle_branch/buf.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -64,7 +64,7 @@ impl TaprootMerkleBranchBuf {
         if collection.as_ref().len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(collection.as_ref().len()))
         } else {
-            Ok(TaprootMerkleBranchBuf(collection.into()))
+            Ok(Self(collection.into()))
         }
     }
 
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 723f61a87c..32835a4ec1 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -5,7 +5,6 @@
 //! This module provides support for Taproot tagged hashes.
 
 pub mod merkle_branch;
-pub mod serialized_signature;
 
 use core::cmp::{Ordering, Reverse};
 use core::convert::Infallible;
@@ -19,7 +18,7 @@ use internals::array::ArrayExt;
 use internals::slice::SliceExt;
 use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::Write;
-use secp256k1::{Scalar, Secp256k1};
+use secp256k1::Scalar;
 
 use crate::consensus::Encodable;
 use crate::crypto::key::{
@@ -27,12 +26,12 @@ use crate::crypto::key::{
 };
 use crate::key::ParseXOnlyPublicKeyError;
 use crate::prelude::{BTreeMap, BTreeSet, BinaryHeap, Vec};
-use crate::{Script, ScriptBuf};
+use crate::{TapScript, TapScriptBuf};
 
 // Re-export these so downstream only has to use one `taproot` module.
 #[rustfmt::skip]
 #[doc(inline)]
-pub use crate::crypto::taproot::{SigFromSliceError, Signature};
+pub use crate::crypto::taproot::{SerializedSignature, SigFromSliceError, Signature};
 #[doc(inline)]
 pub use merkle_branch::TaprootMerkleBranch;
 #[doc(inline)]
@@ -43,7 +42,7 @@ pub use crate::XOnlyPublicKey;
 
 type ControlBlockArrayVec = internals::array_vec::ArrayVec<u8, TAPROOT_CONTROL_MAX_SIZE>;
 
-// Taproot test vectors from BIP-341 state the hashes without any reversing
+// Taproot test vectors from BIP-0341 state the hashes without any reversing
 sha256t_tag! {
     pub struct TapLeafTag = hash_str("TapLeaf");
 }
@@ -66,7 +65,7 @@ sha256t_tag! {
 hash_newtype! {
     /// Tagged hash used in Taproot trees.
     ///
-    /// See BIP-340 for tagging rules.
+    /// See BIP-0340 for tagging rules.
     #[repr(transparent)]
     pub struct TapNodeHash(sha256t::Hash<TapBranchTag>);
 }
@@ -91,16 +90,16 @@ hashes::impl_hex_for_newtype!(TapTweakHash);
 hashes::impl_serde_for_newtype!(TapTweakHash);
 
 impl From<TapLeafHash> for TapNodeHash {
-    fn from(leaf: TapLeafHash) -> TapNodeHash { TapNodeHash::from_byte_array(leaf.to_byte_array()) }
+    fn from(leaf: TapLeafHash) -> Self { Self::from_byte_array(leaf.to_byte_array()) }
 }
 
 impl TapTweakHash {
-    /// Constructs a new BIP341 [`TapTweakHash`] from key and Merkle root. Produces `H_taptweak(P||R)` where
+    /// Constructs a new BIP-0341 [`TapTweakHash`] from key and Merkle root. Produces `H_taptweak(P||R)` where
     /// `P` is the internal key and `R` is the Merkle root.
     pub fn from_key_and_merkle_root<K: Into<UntweakedPublicKey>>(
         internal_key: K,
         merkle_root: Option<TapNodeHash>,
-    ) -> TapTweakHash {
+    ) -> Self {
         let internal_key = internal_key.into();
         let mut eng = sha256t::Hash::<TapTweakTag>::engine();
         // always hash the key
@@ -111,7 +110,7 @@ impl TapTweakHash {
             // nothing to hash
         }
         let inner = sha256t::Hash::<TapTweakTag>::from_engine(eng);
-        TapTweakHash::from_byte_array(inner.to_byte_array())
+        Self::from_byte_array(inner.to_byte_array())
     }
 
     /// Converts a `TapTweakHash` into a `Scalar` ready for use with key tweaking API.
@@ -123,39 +122,37 @@ impl TapTweakHash {
 
 impl TapLeafHash {
     /// Computes the leaf hash from components.
-    pub fn from_script(script: &Script, ver: LeafVersion) -> TapLeafHash {
+    pub fn from_script(script: &TapScript, ver: LeafVersion) -> Self {
         let mut eng = sha256t::Hash::<TapLeafTag>::engine();
         ver.to_consensus().consensus_encode(&mut eng).expect("engines don't error");
         script.consensus_encode(&mut eng).expect("engines don't error");
         let inner = sha256t::Hash::<TapLeafTag>::from_engine(eng);
-        TapLeafHash::from_byte_array(inner.to_byte_array())
+        Self::from_byte_array(inner.to_byte_array())
     }
 }
 
 impl From<LeafNode> for TapNodeHash {
-    fn from(leaf: LeafNode) -> TapNodeHash { leaf.node_hash() }
+    fn from(leaf: LeafNode) -> Self { leaf.node_hash() }
 }
 
 impl From<&LeafNode> for TapNodeHash {
-    fn from(leaf: &LeafNode) -> TapNodeHash { leaf.node_hash() }
+    fn from(leaf: &LeafNode) -> Self { leaf.node_hash() }
 }
 
 impl TapNodeHash {
     /// Computes branch hash given two hashes of the nodes underneath it.
-    pub fn from_node_hashes(a: TapNodeHash, b: TapNodeHash) -> TapNodeHash {
-        combine_node_hashes(a, b).0
-    }
+    pub fn from_node_hashes(a: Self, b: Self) -> Self { combine_node_hashes(a, b).0 }
 
     /// Assumes the given 32 byte array as hidden [`TapNodeHash`].
     ///
     /// Similar to [`TapLeafHash::from_byte_array`], but explicitly conveys that the
     /// hash is constructed from a hidden node. This also has better ergonomics
     /// because it does not require the caller to import the Hash trait.
-    pub fn assume_hidden(hash: [u8; 32]) -> TapNodeHash { TapNodeHash::from_byte_array(hash) }
+    pub fn assume_hidden(hash: [u8; 32]) -> Self { Self::from_byte_array(hash) }
 
     /// Computes the [`TapNodeHash`] from a script and a leaf version.
-    pub fn from_script(script: &Script, ver: LeafVersion) -> TapNodeHash {
-        TapNodeHash::from(TapLeafHash::from_script(script, ver))
+    pub fn from_script(script: &TapScript, ver: LeafVersion) -> Self {
+        Self::from(TapLeafHash::from_script(script, ver))
     }
 }
 
@@ -201,12 +198,12 @@ pub const TAPROOT_CONTROL_MAX_SIZE: usize =
 pub struct LeafScript<S> {
     /// The version of the script.
     pub version: LeafVersion,
-    /// The script, usually `ScriptBuf` or `&Script`.
+    /// The script, usually `TapScriptBuf` or `&TapScript`.
     pub script: S,
 }
 
 // type alias for versioned tap script corresponding Merkle proof
-type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranchBuf>>;
+type ScriptMerkleProofMap = BTreeMap<(TapScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranchBuf>>;
 
 /// Represents Taproot spending information.
 ///
@@ -221,15 +218,16 @@ type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootM
 ///   control block.
 ///
 /// If one or more of the spending conditions consist of just a single key (after aggregation), the
-/// most likely key should be made the internal key.
-/// See [BIP341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki) for more details on
-/// choosing internal keys for a Taproot application.
+/// most likely key should be made the internal key. See [BIP-0341] for more details on choosing
+/// internal keys for a Taproot application.
 ///
 /// Note: This library currently does not support
 /// [annex](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-5).
+///
+/// [BIP-0341]: <https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki>
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct TaprootSpendInfo {
-    /// The BIP341 internal key.
+    /// The BIP-0341 internal key.
     internal_key: UntweakedPublicKey,
     /// The Merkle root of the script tree (None if there are no scripts).
     merkle_root: Option<TapNodeHash>,
@@ -249,24 +247,22 @@ impl TaprootSpendInfo {
     /// weights of satisfaction for that script.
     ///
     /// See [`TaprootBuilder::with_huffman_tree`] for more detailed documentation.
-    pub fn with_huffman_tree<C, I, K>(
-        secp: &Secp256k1<C>,
+    pub fn with_huffman_tree<I, K>(
         internal_key: K,
         script_weights: I,
     ) -> Result<Self, TaprootBuilderError>
     where
-        I: IntoIterator<Item = (u32, ScriptBuf)>,
-        C: secp256k1::Verification,
+        I: IntoIterator<Item = (u32, TapScriptBuf)>,
         K: Into<UntweakedPublicKey>,
     {
         let builder = TaprootBuilder::with_huffman_tree(script_weights)?;
-        Ok(builder.finalize(secp, internal_key).expect("Huffman tree is always complete"))
+        Ok(builder.finalize(internal_key).expect("Huffman tree is always complete"))
     }
 
     /// Constructs a new key spend with `internal_key` and `merkle_root`. Provide [`None`] for
     /// the `merkle_root` if there is no script path.
     ///
-    /// *Note*: As per BIP341
+    /// *Note*: As per BIP-0341
     ///
     /// When the Merkle root is [`None`], the output key commits to an unspendable script path
     /// instead of having no script path. This is achieved by computing the output key point as
@@ -274,13 +270,12 @@ impl TaprootSpendInfo {
     ///
     /// Refer to BIP 341 footnote ('Why should the output key always have a Taproot commitment, even
     /// if there is no script path?') for more details.
-    pub fn new_key_spend<C: secp256k1::Verification, K: Into<UntweakedPublicKey>>(
-        secp: &Secp256k1<C>,
+    pub fn new_key_spend<K: Into<UntweakedPublicKey>>(
         internal_key: K,
         merkle_root: Option<TapNodeHash>,
     ) -> Self {
         let internal_key = internal_key.into();
-        let (output_key, parity) = internal_key.tap_tweak(secp, merkle_root);
+        let (output_key, parity) = internal_key.tap_tweak(merkle_root);
         Self {
             internal_key,
             merkle_root,
@@ -315,14 +310,10 @@ impl TaprootSpendInfo {
     ///
     /// This is useful when you want to manually build a Taproot tree without using
     /// [`TaprootBuilder`].
-    pub fn from_node_info<C: secp256k1::Verification, K: Into<UntweakedPublicKey>>(
-        secp: &Secp256k1<C>,
-        internal_key: K,
-        node: NodeInfo,
-    ) -> TaprootSpendInfo {
+    pub fn from_node_info<K: Into<UntweakedPublicKey>>(internal_key: K, node: NodeInfo) -> Self {
         // Create as if it is a key spend path with the given Merkle root
         let root_hash = Some(node.hash);
-        let mut info = TaprootSpendInfo::new_key_spend(secp, internal_key, root_hash);
+        let mut info = Self::new_key_spend(internal_key, root_hash);
 
         for leaves in node.leaves {
             match leaves.leaf {
@@ -354,13 +345,13 @@ impl TaprootSpendInfo {
     ///
     /// - If there are multiple control blocks possible, returns the shortest one.
     /// - If the script is not contained in the [`TaprootSpendInfo`], returns `None`.
-    pub fn control_block(&self, script_ver: &(ScriptBuf, LeafVersion)) -> Option<ControlBlock> {
+    pub fn control_block(&self, script_ver: &(TapScriptBuf, LeafVersion)) -> Option<ControlBlock> {
         let merkle_branch_set = self.script_map.get(script_ver)?;
         // Choose the smallest one amongst the multiple script maps
         let smallest = merkle_branch_set
             .iter()
             .min_by(|x, y| x.len().cmp(&y.len()))
-            .expect("Invariant: ScriptBuf map key must contain non-empty set value");
+            .expect("Invariant: TapScriptBuf map key must contain non-empty set value");
         Some(ControlBlock {
             internal_key: self.internal_key,
             output_key_parity: self.output_key_parity,
@@ -371,11 +362,11 @@ impl TaprootSpendInfo {
 }
 
 impl From<TaprootSpendInfo> for TapTweakHash {
-    fn from(spend_info: TaprootSpendInfo) -> TapTweakHash { spend_info.tap_tweak() }
+    fn from(spend_info: TaprootSpendInfo) -> Self { spend_info.tap_tweak() }
 }
 
 impl From<&TaprootSpendInfo> for TapTweakHash {
-    fn from(spend_info: &TaprootSpendInfo) -> TapTweakHash { spend_info.tap_tweak() }
+    fn from(spend_info: &TaprootSpendInfo) -> Self { spend_info.tap_tweak() }
 }
 
 /// Builder for building Taproot iteratively. Users can specify tap leaf or omitted/hidden branches
@@ -416,20 +407,18 @@ pub struct TaprootBuilder {
     // 128 entries (as that would mean more than 128 levels in the tree). The depth of newly added
     // entries will always be at least equal to the current size of branch (otherwise it does not
     // correspond to a depth-first traversal of a tree). A branch is only empty if no entries have
-    // ever be processed. A branch having length 1 corresponds to being done.
+    // ever been processed. A branch having length 1 corresponds to being done.
     branch: Vec<Option<NodeInfo>>,
 }
 
 impl TaprootBuilder {
     /// Constructs a new instance of [`TaprootBuilder`].
-    pub fn new() -> Self { TaprootBuilder { branch: vec![] } }
+    pub fn new() -> Self { Self { branch: vec![] } }
 
     /// Constructs a new instance of [`TaprootBuilder`] with a capacity hint for `size` elements.
     ///
     /// The size here should be maximum depth of the tree.
-    pub fn with_capacity(size: usize) -> Self {
-        TaprootBuilder { branch: Vec::with_capacity(size) }
-    }
+    pub fn with_capacity(size: usize) -> Self { Self { branch: Vec::with_capacity(size) } }
 
     /// Constructs a new [`TaprootSpendInfo`] from a list of scripts (with default script version) and
     /// weights of satisfaction for that script.
@@ -437,7 +426,7 @@ impl TaprootBuilder {
     /// The weights represent the probability of each branch being taken. If probabilities/weights
     /// for each condition are known, constructing the tree as a Huffman tree is the optimal way to
     /// minimize average case satisfaction cost. This function takes as input an iterator of
-    /// `tuple(u32, ScriptBuf)` where `u32` represents the satisfaction weights of the branch. For
+    /// `tuple(u32, TapScriptBuf)` where `u32` represents the satisfaction weights of the branch. For
     /// example, [(3, S1), (2, S2), (5, S3)] would construct a [`TapTree`] that has optimal
     /// satisfaction weight when probability for S1 is 30%, S2 is 20% and S3 is 50%.
     ///
@@ -454,7 +443,7 @@ impl TaprootBuilder {
     /// [`TapTree`]: crate::taproot::TapTree
     pub fn with_huffman_tree<I>(script_weights: I) -> Result<Self, TaprootBuilderError>
     where
-        I: IntoIterator<Item = (u32, ScriptBuf)>,
+        I: IntoIterator<Item = (u32, TapScriptBuf)>,
     {
         let mut node_weights = BinaryHeap::<(Reverse<u32>, NodeInfo)>::new();
         for (p, leaf) in script_weights {
@@ -479,7 +468,7 @@ impl TaprootBuilder {
         // Therefore, the loop will eventually terminate with exactly 1 element
         debug_assert_eq!(node_weights.len(), 1);
         let node = node_weights.pop().expect("Huffman tree algorithm is broken").1;
-        Ok(TaprootBuilder { branch: vec![Some(node)] })
+        Ok(Self { branch: vec![Some(node)] })
     }
 
     /// Adds a leaf script at `depth` to the builder with script version `ver`.
@@ -492,7 +481,7 @@ impl TaprootBuilder {
     pub fn add_leaf_with_ver(
         self,
         depth: u8,
-        script: ScriptBuf,
+        script: TapScriptBuf,
         ver: LeafVersion,
     ) -> Result<Self, TaprootBuilderError> {
         let leaf = NodeInfo::new_leaf_with_ver(script, ver);
@@ -508,7 +497,7 @@ impl TaprootBuilder {
     /// # Errors
     ///
     /// Errors if the leaves are not provided in DFS walk order.
-    pub fn add_leaf(self, depth: u8, script: ScriptBuf) -> Result<Self, TaprootBuilderError> {
+    pub fn add_leaf(self, depth: u8, script: TapScriptBuf) -> Result<Self, TaprootBuilderError> {
         self.add_leaf_with_ver(depth, script, LeafVersion::TapScript)
     }
 
@@ -570,9 +559,7 @@ impl TaprootBuilder {
         let node = self.try_into_node_info()?;
         if node.has_hidden_nodes {
             // Reconstruct the builder as it was if it has hidden nodes
-            return Err(IncompleteBuilderError::HiddenParts(TaprootBuilder {
-                branch: vec![Some(node)],
-            }));
+            return Err(IncompleteBuilderError::HiddenParts(Self { branch: vec![Some(node)] }));
         }
         Ok(TapTree(node))
     }
@@ -586,17 +573,16 @@ impl TaprootBuilder {
     ///
     /// Returns the unmodified builder as Err if the builder is not finalizable.
     /// See also [`TaprootBuilder::is_finalizable`]
-    pub fn finalize<C: secp256k1::Verification, K: Into<XOnlyPublicKey>>(
+    pub fn finalize<K: Into<XOnlyPublicKey>>(
         mut self,
-        secp: &Secp256k1<C>,
         internal_key: K,
-    ) -> Result<TaprootSpendInfo, TaprootBuilder> {
+    ) -> Result<TaprootSpendInfo, Self> {
         let internal_key = internal_key.into();
         match self.branch.len() {
-            0 => Ok(TaprootSpendInfo::new_key_spend(secp, internal_key, None)),
+            0 => Ok(TaprootSpendInfo::new_key_spend(internal_key, None)),
             1 =>
                 if let Some(Some(node)) = self.branch.pop() {
-                    Ok(TaprootSpendInfo::from_node_info(secp, internal_key, node))
+                    Ok(TaprootSpendInfo::from_node_info(internal_key, node))
                 } else {
                     unreachable!("size checked above. Builder guarantees the last element is Some")
                 },
@@ -609,7 +595,7 @@ impl TaprootBuilder {
     /// Inserts a leaf at `depth`.
     fn insert(mut self, mut node: NodeInfo, mut depth: u8) -> Result<Self, TaprootBuilderError> {
         // early error on invalid depth. Though this will be checked later
-        // while constructing TaprootMerkelBranch
+        // while constructing TaprootMerkleBranch
         if depth as usize > TAPROOT_CONTROL_MAX_NODE_COUNT {
             return Err(InvalidMerkleTreeDepthError(depth as usize).into());
         }
@@ -674,22 +660,18 @@ impl From<Infallible> for IncompleteBuilderError {
 impl IncompleteBuilderError {
     /// Converts error into the original incomplete [`TaprootBuilder`] instance.
     pub fn into_builder(self) -> TaprootBuilder {
-        use IncompleteBuilderError::*;
-
         match self {
-            NotFinalized(builder) | HiddenParts(builder) => builder,
+            Self::NotFinalized(builder) | Self::HiddenParts(builder) => builder,
         }
     }
 }
 
 impl core::fmt::Display for IncompleteBuilderError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        use IncompleteBuilderError::*;
-
         f.write_str(match self {
-            NotFinalized(_) =>
+            Self::NotFinalized(_) =>
                 "an attempt to construct a Taproot tree from a builder containing incomplete branches",
-            HiddenParts(_) =>
+            Self::HiddenParts(_) =>
                 "an attempt to construct a Taproot tree from a builder containing hidden parts",
         })
     }
@@ -698,10 +680,8 @@ impl core::fmt::Display for IncompleteBuilderError {
 #[cfg(feature = "std")]
 impl std::error::Error for IncompleteBuilderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use IncompleteBuilderError::*;
-
-        match *self {
-            NotFinalized(_) | HiddenParts(_) => None,
+        match self {
+            Self::NotFinalized(_) | Self::HiddenParts(_) => None,
         }
     }
 }
@@ -722,20 +702,16 @@ impl From<Infallible> for HiddenNodesError {
 impl HiddenNodesError {
     /// Converts error into the original incomplete [`NodeInfo`] instance.
     pub fn into_node_info(self) -> NodeInfo {
-        use HiddenNodesError::*;
-
         match self {
-            HiddenParts(node_info) => node_info,
+            Self::HiddenParts(node_info) => node_info,
         }
     }
 }
 
 impl core::fmt::Display for HiddenNodesError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        use HiddenNodesError::*;
-
         f.write_str(match self {
-            HiddenParts(_) =>
+            Self::HiddenParts(_) =>
                 "an attempt to construct a Taproot tree from a node_info containing hidden parts",
         })
     }
@@ -744,10 +720,8 @@ impl core::fmt::Display for HiddenNodesError {
 #[cfg(feature = "std")]
 impl std::error::Error for HiddenNodesError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use HiddenNodesError::*;
-
         match self {
-            HiddenParts(_) => None,
+            Self::HiddenParts(_) => None,
         }
     }
 }
@@ -757,7 +731,7 @@ impl std::error::Error for HiddenNodesError {
 /// This is in contrast to [`NodeInfo`], which allows hidden nodes.
 /// The implementations for Eq, PartialEq and Hash compare the Merkle root of the tree
 //
-// This is a bug in BIP370 that does not specify how to share trees with hidden nodes,
+// This is a bug in BIP-0370 that does not specify how to share trees with hidden nodes,
 // for which we need a separate type.
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -777,9 +751,11 @@ impl TapTree {
     /// Gets the inner [`NodeInfo`] of this tree root.
     pub fn into_node_info(self) -> NodeInfo { self.0 }
 
-    /// Returns [`TapTreeIter<'_>`] iterator for a Taproot script tree, operating in DFS order over
+    /// Returns [`ScriptLeaves<'_>`] iterator for a Taproot script tree, operating in DFS order over
     /// tree [`ScriptLeaf`]s.
-    pub fn script_leaves(&self) -> ScriptLeaves { ScriptLeaves { leaf_iter: self.0.leaf_nodes() } }
+    pub fn script_leaves(&self) -> ScriptLeaves<'_> {
+        ScriptLeaves { leaf_iter: self.0.leaf_nodes() }
+    }
 
     /// Returns the root [`TapNodeHash`] of this tree.
     pub fn root_hash(&self) -> TapNodeHash { self.0.hash }
@@ -792,7 +768,7 @@ impl TryFrom<TaprootBuilder> for TapTree {
     ///
     /// # Returns
     ///
-    /// A [`TapTree`] iff the `builder` is complete, otherwise return [`IncompleteBuilderError`]
+    /// A [`TapTree`] if and only if the `builder` is complete, otherwise return [`IncompleteBuilderError`]
     /// error with the content of incomplete `builder` instance.
     fn try_from(builder: TaprootBuilder) -> Result<Self, Self::Error> {
         builder.try_into_tap_tree()
@@ -806,13 +782,13 @@ impl TryFrom<NodeInfo> for TapTree {
     ///
     /// # Returns
     ///
-    /// A [`TapTree`] iff the [`NodeInfo`] has no hidden nodes, otherwise return
+    /// A [`TapTree`] if and only if the [`NodeInfo`] has no hidden nodes, otherwise return
     /// [`HiddenNodesError`] error with the content of incomplete [`NodeInfo`] instance.
     fn try_from(node_info: NodeInfo) -> Result<Self, Self::Error> {
         if node_info.has_hidden_nodes {
             Err(HiddenNodesError::HiddenParts(node_info))
         } else {
-            Ok(TapTree(node_info))
+            Ok(Self(node_info))
         }
     }
 }
@@ -902,7 +878,7 @@ impl Ord for NodeInfo {
 }
 
 impl PartialOrd for NodeInfo {
-    fn partial_cmp(&self, other: &NodeInfo) -> Option<Ordering> { Some(self.cmp(other)) }
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
 }
 
 impl PartialEq for NodeInfo {
@@ -921,8 +897,8 @@ impl NodeInfo {
         Self { hash, leaves: vec![], has_hidden_nodes: true }
     }
 
-    /// Constructs a new leaf [`NodeInfo`] with given [`ScriptBuf`] and [`LeafVersion`].
-    pub fn new_leaf_with_ver(script: ScriptBuf, ver: LeafVersion) -> Self {
+    /// Constructs a new leaf [`NodeInfo`] with given [`TapScriptBuf`] and [`LeafVersion`].
+    pub fn new_leaf_with_ver(script: TapScriptBuf, ver: LeafVersion) -> Self {
         Self {
             hash: TapNodeHash::from_script(&script, ver),
             leaves: vec![LeafNode::new_script(script, ver)],
@@ -950,8 +926,8 @@ impl NodeInfo {
         })
     }
 
-    /// Creates an iterator over all leaves (including hidden leaves) in the tree.
-    pub fn leaf_nodes(&self) -> LeafNodes { LeafNodes { leaf_iter: self.leaves.iter() } }
+    /// Constructs an iterator over all leaves (including hidden leaves) in the tree.
+    pub fn leaf_nodes(&self) -> LeafNodes<'_> { LeafNodes { leaf_iter: self.leaves.iter() } }
 
     /// Returns the root [`TapNodeHash`] of this node info.
     pub fn node_hash(&self) -> TapNodeHash { self.hash }
@@ -1042,7 +1018,7 @@ impl<'de> serde::Deserialize<'de> for NodeInfo {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum TapLeaf {
     /// A known script
-    Script(ScriptBuf, LeafVersion),
+    Script(TapScriptBuf, LeafVersion),
     /// Hidden Node with the given leaf hash
     Hidden(TapNodeHash),
 }
@@ -1058,7 +1034,7 @@ impl TapLeaf {
     }
 
     /// Obtains a reference to script and version if the leaf is known.
-    pub fn as_script(&self) -> Option<(&Script, LeafVersion)> {
+    pub fn as_script(&self) -> Option<(&TapScript, LeafVersion)> {
         if let Self::Script(script, ver) = self {
             Some((script, *ver))
         } else {
@@ -1078,7 +1054,7 @@ pub struct LeafNode {
 
 impl LeafNode {
     /// Constructs a new [`ScriptLeaf`] from `script` and `ver` and no Merkle branch.
-    pub fn new_script(script: ScriptBuf, ver: LeafVersion) -> Self {
+    pub fn new_script(script: TapScriptBuf, ver: LeafVersion) -> Self {
         Self { leaf: TapLeaf::Script(script, ver), merkle_branch: Default::default() }
     }
 
@@ -1120,7 +1096,7 @@ impl LeafNode {
 
     /// Returns reference to the leaf script if the leaf is known.
     #[inline]
-    pub fn script(&self) -> Option<&Script> { self.leaf.as_script().map(|x| x.0) }
+    pub fn script(&self) -> Option<&TapScript> { self.leaf.as_script().map(|x| x.0) }
 
     /// Returns leaf version of the script if the leaf is known.
     #[inline]
@@ -1143,7 +1119,7 @@ pub struct ScriptLeaf<'leaf> {
     /// The version of the script leaf.
     version: LeafVersion,
     /// The script.
-    script: &'leaf Script,
+    script: &'leaf TapScript,
     /// The Merkle proof (hashing partners) to get this node.
     merkle_branch: &'leaf TaprootMerkleBranch,
 }
@@ -1153,7 +1129,7 @@ impl<'leaf> ScriptLeaf<'leaf> {
     pub fn version(&self) -> LeafVersion { self.version }
 
     /// Obtains a reference to the script inside the leaf.
-    pub fn script(&self) -> &Script { self.script }
+    pub fn script(&self) -> &TapScript { self.script }
 
     /// Obtains a reference to the Merkle proof of the leaf.
     pub fn merkle_branch(&self) -> &TaprootMerkleBranch { self.merkle_branch }
@@ -1195,7 +1171,7 @@ impl ControlBlock {
     /// - [`TaprootError::InvalidTaprootLeafVersion`] if first byte of `sl` is not a valid leaf version.
     /// - [`TaprootError::InvalidInternalKey`] if internal key is invalid (first 32 bytes after the parity byte).
     /// - [`TaprootError::InvalidMerkleTreeDepth`] if Merkle tree is too deep (more than 128 levels).
-    pub fn decode(sl: &[u8]) -> Result<ControlBlock, TaprootError> {
+    pub fn decode(sl: &[u8]) -> Result<Self, TaprootError> {
         use alloc::borrow::ToOwned;
 
         let ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch } =
@@ -1204,13 +1180,13 @@ impl ControlBlock {
         let internal_key = internal_key.to_validated().map_err(TaprootError::InvalidInternalKey)?;
         let merkle_branch = merkle_branch.to_owned();
 
-        Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
+        Ok(Self { leaf_version, output_key_parity, internal_key, merkle_branch })
     }
 
     /// Constructs a new [`ControlBlock`] from a hex string.
     pub fn from_hex(hex: &str) -> Result<Self, TaprootError> {
         let vec = Vec::from_hex(hex).map_err(TaprootError::InvalidControlBlockHex)?;
-        ControlBlock::decode(vec.as_slice())
+        Self::decode(vec.as_slice())
     }
 }
 
@@ -1234,7 +1210,7 @@ impl<B, K> ControlBlock<B, K> {
         let leaf_version = LeafVersion::from_consensus(first & TAPROOT_LEAF_MASK)?;
         let internal_key = SerializedXOnlyPublicKey::from_bytes_ref(internal_key).into();
         let merkle_branch = TaprootMerkleBranch::decode(merkle_branch)?.into();
-        Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
+        Ok(Self { leaf_version, output_key_parity, internal_key, merkle_branch })
     }
 }
 
@@ -1276,9 +1252,10 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
 
     /// Serializes the control block.
     ///
-    /// This would be required when using [`ControlBlock`] as a witness element while spending an
-    /// output via script path. This serialization does not include the varint prefix that would be
-    /// applied when encoding this element as a witness.
+    /// This is required when using [`ControlBlock`] as a witness element while spending an output
+    /// via a script path. This serialization does not include the length prefix. When the
+    /// serialization returned by this function is later encoded as a witness element the length
+    /// prefix is added.
     pub fn serialize(&self) -> Vec<u8> {
         let mut buf = Vec::with_capacity(self.size());
         self.encode(&mut buf).expect("writers don't error");
@@ -1289,11 +1266,10 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
     ///
     /// Only checks that script is contained inside the [`TapTree`] described by output key. Full
     /// verification must also execute the script with witness data.
-    pub fn verify_taproot_commitment<C: secp256k1::Verification>(
+    pub fn verify_taproot_commitment(
         &self,
-        secp: &Secp256k1<C>,
         output_key: XOnlyPublicKey,
-        script: &Script,
+        script: &TapScript,
     ) -> bool {
         // compute the script hash
         // Initially the curr_hash is the leaf hash
@@ -1306,7 +1282,7 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
         // compute the taptweak
         let tweak =
             TapTweakHash::from_key_and_merkle_root(self.internal_key, Some(curr_hash)).to_scalar();
-        self.internal_key.tweak_add_check(secp, &output_key, self.output_key_parity, tweak)
+        self.internal_key.tweak_add_check(&output_key, self.output_key_parity, tweak)
     }
 }
 
@@ -1318,16 +1294,14 @@ impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<Branch> {
 pub struct FutureLeafVersion(u8);
 
 impl FutureLeafVersion {
-    pub(self) fn from_consensus(
-        version: u8,
-    ) -> Result<FutureLeafVersion, InvalidTaprootLeafVersionError> {
+    pub(self) fn from_consensus(version: u8) -> Result<Self, InvalidTaprootLeafVersionError> {
         match version {
             TAPROOT_LEAF_TAPSCRIPT => unreachable!(
                 "FutureLeafVersion::from_consensus should never be called for 0xC0 value"
             ),
             TAPROOT_ANNEX_PREFIX => Err(InvalidTaprootLeafVersionError(TAPROOT_ANNEX_PREFIX)),
             odd if odd & 0xFE != odd => Err(InvalidTaprootLeafVersionError(odd)),
-            even => Ok(FutureLeafVersion(even)),
+            even => Ok(Self(even)),
         }
     }
 
@@ -1355,7 +1329,7 @@ impl fmt::UpperHex for FutureLeafVersion {
 /// The leaf version for tapleafs.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum LeafVersion {
-    /// BIP-342 tapscript.
+    /// BIP-0342 tapscript.
     TapScript,
 
     /// Future leaf version.
@@ -1371,7 +1345,7 @@ impl LeafVersion {
     /// - If the `version` is 0x50 ([`TAPROOT_ANNEX_PREFIX`]).
     pub fn from_consensus(version: u8) -> Result<Self, InvalidTaprootLeafVersionError> {
         match version {
-            TAPROOT_LEAF_TAPSCRIPT => Ok(LeafVersion::TapScript),
+            TAPROOT_LEAF_TAPSCRIPT => Ok(Self::TapScript),
             TAPROOT_ANNEX_PREFIX => Err(InvalidTaprootLeafVersionError(TAPROOT_ANNEX_PREFIX)),
             future => FutureLeafVersion::from_consensus(future).map(LeafVersion::Future),
         }
@@ -1380,8 +1354,8 @@ impl LeafVersion {
     /// Returns the consensus representation of this [`LeafVersion`].
     pub fn to_consensus(self) -> u8 {
         match self {
-            LeafVersion::TapScript => TAPROOT_LEAF_TAPSCRIPT,
-            LeafVersion::Future(version) => version.to_consensus(),
+            Self::TapScript => TAPROOT_LEAF_TAPSCRIPT,
+            Self::Future(version) => version.to_consensus(),
         }
     }
 }
@@ -1389,10 +1363,10 @@ impl LeafVersion {
 impl fmt::Display for LeafVersion {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match (self, f.alternate()) {
-            (LeafVersion::TapScript, true) => f.write_str("tapscript"),
-            (LeafVersion::TapScript, false) => fmt::Display::fmt(&TAPROOT_LEAF_TAPSCRIPT, f),
-            (LeafVersion::Future(version), true) => write!(f, "future_script_{:#02x}", version.0),
-            (LeafVersion::Future(version), false) => fmt::Display::fmt(version, f),
+            (Self::TapScript, true) => f.write_str("tapscript"),
+            (Self::TapScript, false) => fmt::Display::fmt(&TAPROOT_LEAF_TAPSCRIPT, f),
+            (Self::Future(version), true) => write!(f, "future_script_{:#02x}", version.0),
+            (Self::Future(version), false) => fmt::Display::fmt(version, f),
         }
     }
 }
@@ -1469,7 +1443,7 @@ pub enum TaprootBuilderError {
     NodeNotInDfsOrder,
     /// Two nodes at depth 0 are not allowed.
     OverCompleteTree,
-    /// Called finalize on a empty tree.
+    /// Called finalize on an empty tree.
     EmptyTree,
 }
 
@@ -1479,19 +1453,17 @@ impl From<Infallible> for TaprootBuilderError {
 
 impl fmt::Display for TaprootBuilderError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use TaprootBuilderError::*;
-
-        match *self {
-            InvalidMerkleTreeDepth(ref e) => write_err!(f, "invalid Merkle tree depth"; e),
-            NodeNotInDfsOrder => {
+        match self {
+            Self::InvalidMerkleTreeDepth(ref e) => write_err!(f, "invalid Merkle tree depth"; e),
+            Self::NodeNotInDfsOrder => {
                 write!(f, "add_leaf/add_hidden must be called in DFS walk order",)
             }
-            OverCompleteTree => write!(
+            Self::OverCompleteTree => write!(
                 f,
                 "attempted to create a tree with two nodes at depth 0. There must\
                 only be exactly one node at depth 0",
             ),
-            EmptyTree => {
+            Self::EmptyTree => {
                 write!(f, "called finalize on an empty tree")
             }
         }
@@ -1501,11 +1473,9 @@ impl fmt::Display for TaprootBuilderError {
 #[cfg(feature = "std")]
 impl std::error::Error for TaprootBuilderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use TaprootBuilderError::*;
-
-        match *self {
-            InvalidMerkleTreeDepth(ref e) => Some(e),
-            NodeNotInDfsOrder | OverCompleteTree | EmptyTree => None,
+        match self {
+            Self::InvalidMerkleTreeDepth(ref e) => Some(e),
+            Self::NodeNotInDfsOrder | Self::OverCompleteTree | Self::EmptyTree => None,
         }
     }
 }
@@ -1539,15 +1509,14 @@ impl From<Infallible> for TaprootError {
 
 impl fmt::Display for TaprootError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use TaprootError::*;
-
-        match *self {
-            InvalidMerkleBranchSize(ref e) => write_err!(f, "invalid Merkle branch size"; e),
-            InvalidMerkleTreeDepth(ref e) => write_err!(f, "invalid Merkle tree depth"; e),
-            InvalidTaprootLeafVersion(ref e) => write_err!(f, "invalid Taproot leaf version"; e),
-            InvalidControlBlockSize(ref e) => write_err!(f, "invalid control block size"; e),
-            InvalidControlBlockHex(ref e) => write_err!(f, "invalid control block hex"; e),
-            InvalidInternalKey(ref e) => write_err!(f, "invalid internal x-only key"; e),
+        match self {
+            Self::InvalidMerkleBranchSize(ref e) => write_err!(f, "invalid Merkle branch size"; e),
+            Self::InvalidMerkleTreeDepth(ref e) => write_err!(f, "invalid Merkle tree depth"; e),
+            Self::InvalidTaprootLeafVersion(ref e) =>
+                write_err!(f, "invalid Taproot leaf version"; e),
+            Self::InvalidControlBlockSize(ref e) => write_err!(f, "invalid control block size"; e),
+            Self::InvalidControlBlockHex(ref e) => write_err!(f, "invalid control block hex"; e),
+            Self::InvalidInternalKey(ref e) => write_err!(f, "invalid internal x-only key"; e),
         }
     }
 }
@@ -1555,14 +1524,12 @@ impl fmt::Display for TaprootError {
 #[cfg(feature = "std")]
 impl std::error::Error for TaprootError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use TaprootError::*;
-
         match self {
-            InvalidInternalKey(e) => Some(e),
-            InvalidTaprootLeafVersion(ref e) => Some(e),
-            InvalidMerkleTreeDepth(ref e) => Some(e),
-            InvalidControlBlockHex(ref e) => Some(e),
-            InvalidMerkleBranchSize(_) | InvalidControlBlockSize(_) => None,
+            Self::InvalidInternalKey(e) => Some(e),
+            Self::InvalidTaprootLeafVersion(ref e) => Some(e),
+            Self::InvalidMerkleTreeDepth(ref e) => Some(e),
+            Self::InvalidControlBlockHex(ref e) => Some(e),
+            Self::InvalidMerkleBranchSize(_) | Self::InvalidControlBlockSize(_) => None,
         }
     }
 }
@@ -1674,7 +1641,7 @@ impl fmt::Display for InvalidControlBlockSizeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "Control Block size({}) must be of the form 33 + 32*m where  0 <= m <= {} ",
+            "Control Block size({}) must be of the form 33 + 32*m where 0 <= m <= {} ",
             self.0, TAPROOT_CONTROL_MAX_NODE_COUNT
         )
     }
@@ -1687,12 +1654,11 @@ impl std::error::Error for InvalidControlBlockSizeError {}
 mod test {
     use hashes::sha256;
     use hex::DisplayHex;
-    use secp256k1::VerifyOnly;
 
     use super::*;
     use crate::script::ScriptBufExt as _;
     use crate::sighash::TapSighashTag;
-    use crate::{Address, KnownHrp};
+    use crate::{Address, KnownHrp, ScriptPubKeyBuf};
     extern crate serde_json;
 
     #[cfg(feature = "serde")]
@@ -1778,93 +1744,77 @@ mod test {
         );
     }
 
-    fn _verify_tap_commitments(
-        secp: &Secp256k1<VerifyOnly>,
-        out_spk_hex: &str,
-        script_hex: &str,
-        control_block_hex: &str,
-    ) {
+    fn _verify_tap_commitments(out_spk_hex: &str, script_hex: &str, control_block_hex: &str) {
         let out_pk = out_spk_hex[4..].parse::<XOnlyPublicKey>().unwrap();
         let out_pk = TweakedPublicKey::dangerous_assume_tweaked(out_pk);
-        let script = ScriptBuf::from_hex_no_length_prefix(script_hex).unwrap();
+        let script = TapScriptBuf::from_hex_no_length_prefix(script_hex).unwrap();
         let control_block = ControlBlock::from_hex(control_block_hex).unwrap();
         assert_eq!(control_block_hex, control_block.serialize().to_lower_hex_string());
-        assert!(control_block.verify_taproot_commitment(
-            secp,
-            out_pk.to_x_only_public_key(),
-            &script
-        ));
+        assert!(control_block.verify_taproot_commitment(out_pk.to_x_only_public_key(), &script));
     }
 
     #[test]
     fn control_block_verify() {
-        let secp = Secp256k1::verification_only();
         // test vectors obtained from printing values in feature_taproot.py from Bitcoin Core
-        _verify_tap_commitments(&secp, "51205dc8e62b15e0ebdf44751676be35ba32eed2e84608b290d4061bbff136cd7ba9", "6a", "c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4");
-        _verify_tap_commitments(&secp, "5120e208c869c40d8827101c5ad3238018de0f3f5183d77a0c53d18ac28ddcbcd8ad", "f4", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40090ab1f4890d51115998242ebce636efb9ede1b516d9eb8952dc1068e0335306199aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4da14e029b1e154a85bfd9139e7aa2720b6070a4ceba8264ca61d5d3ac27aceb9ef4b54cd43c2d1fd5e11b5c2e93cf29b91ea3dc5b832201f02f7473a28c63246");
+        _verify_tap_commitments("51205dc8e62b15e0ebdf44751676be35ba32eed2e84608b290d4061bbff136cd7ba9", "6a", "c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4");
+        _verify_tap_commitments("5120e208c869c40d8827101c5ad3238018de0f3f5183d77a0c53d18ac28ddcbcd8ad", "f4", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40090ab1f4890d51115998242ebce636efb9ede1b516d9eb8952dc1068e0335306199aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4da14e029b1e154a85bfd9139e7aa2720b6070a4ceba8264ca61d5d3ac27aceb9ef4b54cd43c2d1fd5e11b5c2e93cf29b91ea3dc5b832201f02f7473a28c63246");
         _verify_tap_commitments(
-            &secp,
             "5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
             "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
             "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
         );
-        _verify_tap_commitments(&secp, "5120580a19e47269414a55eb86d5d0c6c9b371455d9fd2154412a57dec840df99fe1", "6a", "bca0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40042ba1bd1c63c03ccff60d4c4d53a653f87909eb3358e7fa45c9d805231fb08c933e1f4e0f9d17f591df1419df7d5b7eb5f744f404c5ef9ecdb1b89b18cafa3a816d8b5dba3205f9a9c05f866d91f40d2793a7586d502cb42f46c7a11f66ad4aa");
-        _verify_tap_commitments(&secp, "5120228b94a4806254a38d6efa8a134c28ebc89546209559dfe40b2b0493bafacc5b", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009c9aed3dfd11ab0e78bf87ef3bf296269dc4b0f7712140386d6980992bab4b45");
+        _verify_tap_commitments("5120580a19e47269414a55eb86d5d0c6c9b371455d9fd2154412a57dec840df99fe1", "6a", "bca0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40042ba1bd1c63c03ccff60d4c4d53a653f87909eb3358e7fa45c9d805231fb08c933e1f4e0f9d17f591df1419df7d5b7eb5f744f404c5ef9ecdb1b89b18cafa3a816d8b5dba3205f9a9c05f866d91f40d2793a7586d502cb42f46c7a11f66ad4aa");
+        _verify_tap_commitments("5120228b94a4806254a38d6efa8a134c28ebc89546209559dfe40b2b0493bafacc5b", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009c9aed3dfd11ab0e78bf87ef3bf296269dc4b0f7712140386d6980992bab4b45");
         _verify_tap_commitments(
-            &secp,
             "5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
             "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
             "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
         );
         _verify_tap_commitments(
-            &secp,
             "5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
             "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
             "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
         );
-        _verify_tap_commitments(&secp, "5120f2f62e854a0012aeba78cd4ba4a0832447a5262d4c6eb4f1c95c7914b536fc6c", "6a86", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009ad3d30479f0689dbdf59a6b840d60ad485b2effbed1825a75ce19a44e460e09056f60ea686d79cfa4fb79f197b2e905ac857a983be4a5a41a4873e865aa950780c0237de279dc063e67deec46ef8e1bc351bf12c4d67a6d568001faf097e797e6ee620f53cfe0f8acaddf2063c39c3577853bb46d61ffcba5a024c3e1216837");
-        _verify_tap_commitments(&secp, "51202a4772070b49bae68b44315032cdbf9c40c7c2f896781b32b931b73dbfb26d7e", "6af8", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4006f183944a14618fc7fe9ceade0f58e43a19d3c3b179ea6c43c29616413b6971c99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4c3462adec78cd04f3cc156bdadec50def99feae0dc6a23664e8a2b0d42d6ca9eb968dfdf46c23af642b2688351904e0a0630e71ffac5bcaba33b9b2c8a7495ec");
-        _verify_tap_commitments(&secp, "5120a32b0b8cfafe0f0f8d5870030ba4d19a8725ad345cb3c8420f86ac4e0dff6207", "4c", "e8a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400615da7ac8d078e5fc7f4690fc2127ba40f0f97cc070ade5b3a7919783d91ef3f13734aab908ae998e57848a01268fe8217d70bc3ee8ea8ceae158ae964a4b5f3af20b50d7019bf47fde210eee5c52f1cfe71cfca78f2d3e7c1fd828c80351525");
+        _verify_tap_commitments("5120f2f62e854a0012aeba78cd4ba4a0832447a5262d4c6eb4f1c95c7914b536fc6c", "6a86", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009ad3d30479f0689dbdf59a6b840d60ad485b2effbed1825a75ce19a44e460e09056f60ea686d79cfa4fb79f197b2e905ac857a983be4a5a41a4873e865aa950780c0237de279dc063e67deec46ef8e1bc351bf12c4d67a6d568001faf097e797e6ee620f53cfe0f8acaddf2063c39c3577853bb46d61ffcba5a024c3e1216837");
+        _verify_tap_commitments("51202a4772070b49bae68b44315032cdbf9c40c7c2f896781b32b931b73dbfb26d7e", "6af8", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4006f183944a14618fc7fe9ceade0f58e43a19d3c3b179ea6c43c29616413b6971c99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4c3462adec78cd04f3cc156bdadec50def99feae0dc6a23664e8a2b0d42d6ca9eb968dfdf46c23af642b2688351904e0a0630e71ffac5bcaba33b9b2c8a7495ec");
+        _verify_tap_commitments("5120a32b0b8cfafe0f0f8d5870030ba4d19a8725ad345cb3c8420f86ac4e0dff6207", "4c", "e8a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400615da7ac8d078e5fc7f4690fc2127ba40f0f97cc070ade5b3a7919783d91ef3f13734aab908ae998e57848a01268fe8217d70bc3ee8ea8ceae158ae964a4b5f3af20b50d7019bf47fde210eee5c52f1cfe71cfca78f2d3e7c1fd828c80351525");
         _verify_tap_commitments(
-            &secp,
             "5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
             "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
             "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
         );
-        _verify_tap_commitments(&secp, "51208678459f1fa0f80e9b89b8ffdcaf46a022bdf60aa45f1fed9a96145edf4ec400", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001eff29e1a89e650076b8d3c56302881d09c9df215774ed99993aaed14acd6615");
-        _verify_tap_commitments(&secp, "5120017316303aed02bcdec424c851c9eacbe192b013139bd9634c4e19b3475b06e1", "61", "02a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40050462265ca552b23cbb4fe021b474313c8cb87d4a18b3f7bdbeb2b418279ba31fc6509d829cd42336f563363cb3538d78758e0876c71e13012eb2b656eb0edb051a2420a840d5c8c6c762abc7410af2c311f606b20ca2ace56a8139f84b1379a");
-        _verify_tap_commitments(&secp, "5120896d4d5d2236e86c6e9320e86d1a7822e652907cbd508360e8c71aefc127c77d", "61", "14a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001ab0e9d9a4858a0e69605fe9c5a42d739fbe26fa79650e7074f462b02645f7ea1c91802b298cd91e6b5af57c6a013d93397cd2ecbd5569382cc27becf44ff4fff8960b20f846160c159c58350f6b6072cf1b3daa5185b7a42524fb72cbc252576ae46732b8e31ac24bfa7d72f4c3713e8696f99d8ac6c07e4c820a03f249f144");
-        _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
-        _verify_tap_commitments(&secp, "5120b28d75a7179de6feb66b8bb0bfa2b2c739d1a41cf7366a1b393804a844db8a28", "61", "c4a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400eebc95ded88fb8050094e8dfa958c3be0894eaff0fafae678206b26918d8d7ac47039d40fe34d04b4155df7f1be7f2a49253c7e87812ea9e569e683ac27459e652d6503aa32d64734d00adfee8798b2eed28858abf3bd038e8fa58eb7df4a2d9");
-        _verify_tap_commitments(&secp, "512043e4aa733fc6f43c78a31c2b3c192623acf5cc8c01199ebcc4de88067baca83e", "bd4c", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003f7be6f8848b5bddf332c4d7bd83077f73701e2479f70e02b5730e841234d082b8b41ebea96ffd937715d9faeaa6895e6ef3b22919c554b75df12b3371d328023e443d1df50634ecc1cd169803a1e546f0d44304d8fc5056c408e597fed469b8437d6660eaad3cf72e35ba6e5ff7ddd5e293c1e7e813c871df4f46508e9946ec");
-        _verify_tap_commitments(&secp, "5120ee9aecb28f5f35ce1f8b5ec80275ac0f81bca4a21b29b4632fb4bcbef8823e6a", "2021a5981b13be29c9d4ea179ea44a8b773ea8c02d68f6f6eefd98de20d4bd055fac", "c13359c284c196b6e80f0cf1d93b6a397cf7ee722f0427b705bd954b88ada8838bd2622fd0e104fc50aa763b43c6a792d7d117029983abd687223b4344a9402c618bba7f5fc3fa8a57491f6842acde88c1e675ca35caea3b1a69ee2c2d9b10f615");
-        _verify_tap_commitments(&secp, "5120885274df2252b44764dcef53c21f21154e8488b7e79fafbc96b9ebb22ad0200d", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4000793597254158918e3369507f2d6fdbef17d18b1028bbb0719450ded0f42c58f");
-        _verify_tap_commitments(&secp, "512066f6f6f91d47674d198a28388e1eb05ec24e6ddbba10f16396b1a80c08675121", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400fe92aff70a2e8e2a4f34a913b99612468a41e0f8ecaff9a729a173d11013c27e");
-        _verify_tap_commitments(&secp, "5120868ed9307bd4637491ff03e3aa2c216a08fe213cac8b6cedbb9ab31dbfa6512c", "61", "a2a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400da584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e46c7eccffefd2d573ec014130e508f0c9963ccebd7830409f7b1b1301725e9fa759d4ef857ec8e0bb42d6d31609d3c7e77de3bfa28c38f93393a6ddbabe819ec560ed4f061fbe742a5fd2a648d5209469420434c8753da3fa7067cc2bb4c172a");
-        _verify_tap_commitments(&secp, "5120c1a00a9baa82888fd7d30291135a7eaa9e9966a5f16db2b10460572f8b108d8d", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5ba0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007960d7b37dd1361aee34510e77acb4d27ddca17648a17e28475032538c1eb500f5a747f2c0893f79fe153ae918ac3d696de9322aa679aae62051ff5ed83aa502b338bd907346abd4cd9cf06117cb35d55a5a8dd950843522f8de7b5c7fba1804c38b0778d3d76b383f6db6fdf9d6e770da8fffbfa5152c0b8b38129885bcdee6");
-        _verify_tap_commitments(&secp, "5120bb9abeff7286b76dfc61800c548fe2621ff47506e47201a85c543b4a9a96fead", "75203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf47342796ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003eb5cdc419e0a6a800f34583ce750f387be34879c26f4230991bd61da743ad9d34d288e79397b709ac22ad8cc57645d593af3e15b97a876362117177ab2519c000000000000000000000000000000000000000000000000000000000000000007160c3a48c8b17bc3aeaf01db9e0a96ac47a5a9fa329e046856e7765e89c8a93ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07feb9aa7cd72c78e66a85414cd19289f8b0ab1415013dc2a007666aa9248ec1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fccc8bea662a9442a94f7ba0643c1d7ee7cc689f3b3506b7c8c99fd3f3b3d7772972dcdf2550cf95b65098aea67f72fef10abdcf1cef9815af8f4c4644b060e0000000000000000000000000000000000000000000000000000000000000000");
-        _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "4d09024747703eb9f759ce5ecd839109fecc40974ab16f5173ea390daaa5a78f7abe898165c90990062af998c5dc7989818393158a2c62b7ece727e7f5400d2efd33db8732599f6d1dce6b5b68d2d47317f2de6c9df118f61227f98453225036618aaf058140f2415d134fa69ba041c724ad81387f8c568d12ddc49eb32a71532096181b3f85fd465b8e9a176bb19f45c070baad47a2cc4505414b88c31cb5b0a192b2d2d56c404a37070b04d42c875c4ac351224f5b254f9ad0b820f43cad292d6565f796bf083173e14723f1e543c85a61689ddd5cb6666b240c15c38ce3320bf0c3be9e0322e5ef72366c294d3a2d7e8b8e7db875e7ae814537554f10b91c72b8b413e026bd5d5e917de4b54fa8f43f38771a7f242aa32dcb7ca1b0588dbf54af7ab9455047fbb894cdfdd242166db784276430eb47d4df092a6b8cb160eb982fe7d14a44283bdb4a9861ca65c06fd8b2546cfbfe38bc77f527de1b9bfd2c95a3e283b7b1d1d2b2fa291256a90a7003aefcef47ceabf113865a494af43e96a38b0b00919855eb7722ea2363e0ddfc9c51c08631d01e2a2d56e786b4ff6f1e5d415facc9c2619c285d9ad43001878294157cb025f639fb954271fd1d6173f6bc16535672f6abdd72b0284b4ff3eaf5b7247719d7c39365622610efae6562bef6e08a0b370fba75bb04dbdb90a482d8417e057f8bd021ea6ac32d0d48b08be9f77833b11e5e739960c9837d7583", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400ff698adfda0327f188e2ee35f7aecc0f90c9138a350d450648d968c2b5dd7ef94ddd3ec418dc0d03ee4956feb708d838ed2b20e5a193465a6a1467fd3054e1ea141ea4c4c503a6271e19a090e2a69a24282e3be04c4f98720f7a0eb274d9693d13a8e3c139aa625fa2aefd09854570527f9ac545bda1b689719f5cb715612c07");
-        _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "83", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007388cda01113397d4cd00bcfbd08fd68c3cfe3a42cbfe3a7651c1d5e6dacf1ad99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4b59764bec92507e4a4c3f01a06f05980163ca10f1c549bfe01f85fa4f109a1295e607f5ed9f1008048474de336f11f67a1fbf2012f58944dede0ab19a3ca81f5");
-        _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+        _verify_tap_commitments("51208678459f1fa0f80e9b89b8ffdcaf46a022bdf60aa45f1fed9a96145edf4ec400", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001eff29e1a89e650076b8d3c56302881d09c9df215774ed99993aaed14acd6615");
+        _verify_tap_commitments("5120017316303aed02bcdec424c851c9eacbe192b013139bd9634c4e19b3475b06e1", "61", "02a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40050462265ca552b23cbb4fe021b474313c8cb87d4a18b3f7bdbeb2b418279ba31fc6509d829cd42336f563363cb3538d78758e0876c71e13012eb2b656eb0edb051a2420a840d5c8c6c762abc7410af2c311f606b20ca2ace56a8139f84b1379a");
+        _verify_tap_commitments("5120896d4d5d2236e86c6e9320e86d1a7822e652907cbd508360e8c71aefc127c77d", "61", "14a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001ab0e9d9a4858a0e69605fe9c5a42d739fbe26fa79650e7074f462b02645f7ea1c91802b298cd91e6b5af57c6a013d93397cd2ecbd5569382cc27becf44ff4fff8960b20f846160c159c58350f6b6072cf1b3daa5185b7a42524fb72cbc252576ae46732b8e31ac24bfa7d72f4c3713e8696f99d8ac6c07e4c820a03f249f144");
+        _verify_tap_commitments("512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+        _verify_tap_commitments("5120b28d75a7179de6feb66b8bb0bfa2b2c739d1a41cf7366a1b393804a844db8a28", "61", "c4a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400eebc95ded88fb8050094e8dfa958c3be0894eaff0fafae678206b26918d8d7ac47039d40fe34d04b4155df7f1be7f2a49253c7e87812ea9e569e683ac27459e652d6503aa32d64734d00adfee8798b2eed28858abf3bd038e8fa58eb7df4a2d9");
+        _verify_tap_commitments("512043e4aa733fc6f43c78a31c2b3c192623acf5cc8c01199ebcc4de88067baca83e", "bd4c", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003f7be6f8848b5bddf332c4d7bd83077f73701e2479f70e02b5730e841234d082b8b41ebea96ffd937715d9faeaa6895e6ef3b22919c554b75df12b3371d328023e443d1df50634ecc1cd169803a1e546f0d44304d8fc5056c408e597fed469b8437d6660eaad3cf72e35ba6e5ff7ddd5e293c1e7e813c871df4f46508e9946ec");
+        _verify_tap_commitments("5120ee9aecb28f5f35ce1f8b5ec80275ac0f81bca4a21b29b4632fb4bcbef8823e6a", "2021a5981b13be29c9d4ea179ea44a8b773ea8c02d68f6f6eefd98de20d4bd055fac", "c13359c284c196b6e80f0cf1d93b6a397cf7ee722f0427b705bd954b88ada8838bd2622fd0e104fc50aa763b43c6a792d7d117029983abd687223b4344a9402c618bba7f5fc3fa8a57491f6842acde88c1e675ca35caea3b1a69ee2c2d9b10f615");
+        _verify_tap_commitments("5120885274df2252b44764dcef53c21f21154e8488b7e79fafbc96b9ebb22ad0200d", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4000793597254158918e3369507f2d6fdbef17d18b1028bbb0719450ded0f42c58f");
+        _verify_tap_commitments("512066f6f6f91d47674d198a28388e1eb05ec24e6ddbba10f16396b1a80c08675121", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400fe92aff70a2e8e2a4f34a913b99612468a41e0f8ecaff9a729a173d11013c27e");
+        _verify_tap_commitments("5120868ed9307bd4637491ff03e3aa2c216a08fe213cac8b6cedbb9ab31dbfa6512c", "61", "a2a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400da584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e46c7eccffefd2d573ec014130e508f0c9963ccebd7830409f7b1b1301725e9fa759d4ef857ec8e0bb42d6d31609d3c7e77de3bfa28c38f93393a6ddbabe819ec560ed4f061fbe742a5fd2a648d5209469420434c8753da3fa7067cc2bb4c172a");
+        _verify_tap_commitments("5120c1a00a9baa82888fd7d30291135a7eaa9e9966a5f16db2b10460572f8b108d8d", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5ba0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007960d7b37dd1361aee34510e77acb4d27ddca17648a17e28475032538c1eb500f5a747f2c0893f79fe153ae918ac3d696de9322aa679aae62051ff5ed83aa502b338bd907346abd4cd9cf06117cb35d55a5a8dd950843522f8de7b5c7fba1804c38b0778d3d76b383f6db6fdf9d6e770da8fffbfa5152c0b8b38129885bcdee6");
+        _verify_tap_commitments("5120bb9abeff7286b76dfc61800c548fe2621ff47506e47201a85c543b4a9a96fead", "75203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf47342796ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003eb5cdc419e0a6a800f34583ce750f387be34879c26f4230991bd61da743ad9d34d288e79397b709ac22ad8cc57645d593af3e15b97a876362117177ab2519c000000000000000000000000000000000000000000000000000000000000000007160c3a48c8b17bc3aeaf01db9e0a96ac47a5a9fa329e046856e7765e89c8a93ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07feb9aa7cd72c78e66a85414cd19289f8b0ab1415013dc2a007666aa9248ec1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fccc8bea662a9442a94f7ba0643c1d7ee7cc689f3b3506b7c8c99fd3f3b3d7772972dcdf2550cf95b65098aea67f72fef10abdcf1cef9815af8f4c4644b060e0000000000000000000000000000000000000000000000000000000000000000");
+        _verify_tap_commitments("5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "4d09024747703eb9f759ce5ecd839109fecc40974ab16f5173ea390daaa5a78f7abe898165c90990062af998c5dc7989818393158a2c62b7ece727e7f5400d2efd33db8732599f6d1dce6b5b68d2d47317f2de6c9df118f61227f98453225036618aaf058140f2415d134fa69ba041c724ad81387f8c568d12ddc49eb32a71532096181b3f85fd465b8e9a176bb19f45c070baad47a2cc4505414b88c31cb5b0a192b2d2d56c404a37070b04d42c875c4ac351224f5b254f9ad0b820f43cad292d6565f796bf083173e14723f1e543c85a61689ddd5cb6666b240c15c38ce3320bf0c3be9e0322e5ef72366c294d3a2d7e8b8e7db875e7ae814537554f10b91c72b8b413e026bd5d5e917de4b54fa8f43f38771a7f242aa32dcb7ca1b0588dbf54af7ab9455047fbb894cdfdd242166db784276430eb47d4df092a6b8cb160eb982fe7d14a44283bdb4a9861ca65c06fd8b2546cfbfe38bc77f527de1b9bfd2c95a3e283b7b1d1d2b2fa291256a90a7003aefcef47ceabf113865a494af43e96a38b0b00919855eb7722ea2363e0ddfc9c51c08631d01e2a2d56e786b4ff6f1e5d415facc9c2619c285d9ad43001878294157cb025f639fb954271fd1d6173f6bc16535672f6abdd72b0284b4ff3eaf5b7247719d7c39365622610efae6562bef6e08a0b370fba75bb04dbdb90a482d8417e057f8bd021ea6ac32d0d48b08be9f77833b11e5e739960c9837d7583", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400ff698adfda0327f188e2ee35f7aecc0f90c9138a350d450648d968c2b5dd7ef94ddd3ec418dc0d03ee4956feb708d838ed2b20e5a193465a6a1467fd3054e1ea141ea4c4c503a6271e19a090e2a69a24282e3be04c4f98720f7a0eb274d9693d13a8e3c139aa625fa2aefd09854570527f9ac545bda1b689719f5cb715612c07");
+        _verify_tap_commitments("5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "83", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007388cda01113397d4cd00bcfbd08fd68c3cfe3a42cbfe3a7651c1d5e6dacf1ad99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4b59764bec92507e4a4c3f01a06f05980163ca10f1c549bfe01f85fa4f109a1295e607f5ed9f1008048474de336f11f67a1fbf2012f58944dede0ab19a3ca81f5");
+        _verify_tap_commitments("512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
     }
 
     #[test]
     fn build_huffman_tree() {
-        let secp = Secp256k1::verification_only();
         let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
             .parse::<UntweakedPublicKey>()
             .unwrap();
 
         let script_weights = [
-            (10, ScriptBuf::from_hex_no_length_prefix("51").unwrap()), // semantics of script don't matter for this test
-            (20, ScriptBuf::from_hex_no_length_prefix("52").unwrap()),
-            (20, ScriptBuf::from_hex_no_length_prefix("53").unwrap()),
-            (30, ScriptBuf::from_hex_no_length_prefix("54").unwrap()),
-            (19, ScriptBuf::from_hex_no_length_prefix("55").unwrap()),
+            (10, TapScriptBuf::from_hex_no_length_prefix("51").unwrap()), // semantics of script don't matter for this test
+            (20, TapScriptBuf::from_hex_no_length_prefix("52").unwrap()),
+            (20, TapScriptBuf::from_hex_no_length_prefix("53").unwrap()),
+            (30, TapScriptBuf::from_hex_no_length_prefix("54").unwrap()),
+            (19, TapScriptBuf::from_hex_no_length_prefix("55").unwrap()),
         ];
         let tree_info =
-            TaprootSpendInfo::with_huffman_tree(&secp, internal_key, script_weights.clone())
-                .unwrap();
+            TaprootSpendInfo::with_huffman_tree(internal_key, script_weights.clone()).unwrap();
 
         /* The resulting tree should put the scripts into a tree similar
          * to the following:
@@ -1882,7 +1832,7 @@ mod test {
                 tree_info
                     .script_map
                     .get(&(
-                        ScriptBuf::from_hex_no_length_prefix(script).unwrap(),
+                        TapScriptBuf::from_hex_no_length_prefix(script).unwrap(),
                         LeafVersion::TapScript
                     ))
                     .expect("Present Key")
@@ -1900,17 +1850,13 @@ mod test {
         for (_weights, script) in script_weights {
             let ver_script = (script, LeafVersion::TapScript);
             let ctrl_block = tree_info.control_block(&ver_script).unwrap();
-            assert!(ctrl_block.verify_taproot_commitment(
-                &secp,
-                output_key.to_x_only_public_key(),
-                &ver_script.0
-            ))
+            assert!(ctrl_block
+                .verify_taproot_commitment(output_key.to_x_only_public_key(), &ver_script.0))
         }
     }
 
     #[test]
     fn taptree_builder() {
-        let secp = Secp256k1::verification_only();
         let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
             .parse::<UntweakedPublicKey>()
             .unwrap();
@@ -1925,18 +1871,18 @@ mod test {
         //                                   /  \    /  \
         //                                  A    B  C  / \
         //                                            D   E
-        let a = ScriptBuf::from_hex_no_length_prefix("51").unwrap();
-        let b = ScriptBuf::from_hex_no_length_prefix("52").unwrap();
-        let c = ScriptBuf::from_hex_no_length_prefix("53").unwrap();
-        let d = ScriptBuf::from_hex_no_length_prefix("54").unwrap();
-        let e = ScriptBuf::from_hex_no_length_prefix("55").unwrap();
+        let a = TapScriptBuf::from_hex_no_length_prefix("51").unwrap();
+        let b = TapScriptBuf::from_hex_no_length_prefix("52").unwrap();
+        let c = TapScriptBuf::from_hex_no_length_prefix("53").unwrap();
+        let d = TapScriptBuf::from_hex_no_length_prefix("54").unwrap();
+        let e = TapScriptBuf::from_hex_no_length_prefix("55").unwrap();
         let builder = builder.add_leaf(2, a.clone()).unwrap();
         let builder = builder.add_leaf(2, b.clone()).unwrap();
         let builder = builder.add_leaf(2, c.clone()).unwrap();
         let builder = builder.add_leaf(3, d.clone()).unwrap();
 
         // Trying to finalize an incomplete tree returns the Err(builder)
-        let builder = builder.finalize(&secp, internal_key).unwrap_err();
+        let builder = builder.finalize(internal_key).unwrap_err();
         let builder = builder.add_leaf(3, e.clone()).unwrap();
 
         #[cfg(feature = "serde")]
@@ -1968,17 +1914,14 @@ mod test {
             ],);
         }
 
-        let tree_info = builder.finalize(&secp, internal_key).unwrap();
+        let tree_info = builder.finalize(internal_key).unwrap();
         let output_key = tree_info.output_key();
 
         for script in [a, b, c, d, e] {
             let ver_script = (script, LeafVersion::TapScript);
             let ctrl_block = tree_info.control_block(&ver_script).unwrap();
-            assert!(ctrl_block.verify_taproot_commitment(
-                &secp,
-                output_key.to_x_only_public_key(),
-                &ver_script.0
-            ))
+            assert!(ctrl_block
+                .verify_taproot_commitment(output_key.to_x_only_public_key(), &ver_script.0))
         }
     }
 
@@ -2027,7 +1970,7 @@ mod test {
         fn process_script_trees(
             v: &serde_json::Value,
             mut builder: TaprootBuilder,
-            leaves: &mut Vec<(ScriptBuf, LeafVersion)>,
+            leaves: &mut Vec<(TapScriptBuf, LeafVersion)>,
             depth: u8,
         ) -> TaprootBuilder {
             if v.is_null() {
@@ -2038,7 +1981,7 @@ mod test {
                 }
             } else {
                 let script =
-                    ScriptBuf::from_hex_no_length_prefix(v["script"].as_str().unwrap()).unwrap();
+                    TapScriptBuf::from_hex_no_length_prefix(v["script"].as_str().unwrap()).unwrap();
                 let ver =
                     LeafVersion::from_consensus(v["leafVersion"].as_u64().unwrap() as u8).unwrap();
                 leaves.push((script.clone(), ver));
@@ -2050,7 +1993,6 @@ mod test {
         let data = bip_341_read_json();
         // Check the version of data
         assert!(data["version"] == 1);
-        let secp = &secp256k1::Secp256k1::verification_only();
 
         for arr in data["scriptPubKey"].as_array().unwrap() {
             let internal_key =
@@ -2073,7 +2015,7 @@ mod test {
                 let mut builder = TaprootBuilder::new();
                 let mut leaves = vec![];
                 builder = process_script_trees(script_tree, builder, &mut leaves, 0);
-                let spend_info = builder.finalize(secp, internal_key).unwrap();
+                let spend_info = builder.finalize(internal_key).unwrap();
                 for (i, script_ver) in leaves.iter().enumerate() {
                     let expected_leaf_hash = leaf_hashes[i].as_str().unwrap();
                     let expected_ctrl_blk =
@@ -2092,7 +2034,7 @@ mod test {
                 .unwrap();
             let expected_tweak =
                 arr["intermediary"]["tweak"].as_str().unwrap().parse::<TapTweakHash>().unwrap();
-            let expected_spk = ScriptBuf::from_hex_no_length_prefix(
+            let expected_spk = ScriptPubKeyBuf::from_hex_no_length_prefix(
                 arr["expected"]["scriptPubKey"].as_str().unwrap(),
             )
             .unwrap();
@@ -2104,8 +2046,8 @@ mod test {
                 .assume_checked();
 
             let tweak = TapTweakHash::from_key_and_merkle_root(internal_key, merkle_root);
-            let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);
-            let addr = Address::p2tr(secp, internal_key, merkle_root, KnownHrp::Mainnet);
+            let (output_key, _parity) = internal_key.tap_tweak(merkle_root);
+            let addr = Address::p2tr(internal_key, merkle_root, KnownHrp::Mainnet);
             let spk = addr.script_pubkey();
 
             assert_eq!(expected_output_key, output_key.to_x_only_public_key());
diff --git a/bitcoin/src/taproot/serialized_signature.rs b/bitcoin/src/taproot/serialized_signature.rs
deleted file mode 100644
index a63af0fe21..0000000000
--- a/bitcoin/src/taproot/serialized_signature.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-//! Implements [`SerializedSignature`] and related types.
-//!
-//! Serialized Taproot signatures have the issue that they can have different lengths.
-//! We want to avoid using `Vec` since that would require allocations making the code slower and
-//! unable to run on platforms without an allocator. We implement a special type to encapsulate
-//! serialized signatures and since it's a bit more complicated it has its own module.
-
-use core::borrow::Borrow;
-use core::{fmt, ops};
-
-pub use into_iter::IntoIter;
-use io::Write;
-
-use super::{SigFromSliceError, Signature};
-
-pub(crate) const MAX_LEN: usize = 65; // 64 for sig, 1B sighash flag
-
-/// A serialized Taproot Signature
-#[derive(Copy, Clone)]
-pub struct SerializedSignature {
-    data: [u8; MAX_LEN],
-    len: usize,
-}
-
-impl fmt::Debug for SerializedSignature {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self, f) }
-}
-
-impl fmt::Display for SerializedSignature {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        hex::fmt_hex_exact!(f, MAX_LEN, self, hex::Case::Lower)
-    }
-}
-
-impl PartialEq for SerializedSignature {
-    #[inline]
-    fn eq(&self, other: &SerializedSignature) -> bool { **self == **other }
-}
-
-impl PartialEq<[u8]> for SerializedSignature {
-    #[inline]
-    fn eq(&self, other: &[u8]) -> bool { **self == *other }
-}
-
-impl PartialEq<SerializedSignature> for [u8] {
-    #[inline]
-    fn eq(&self, other: &SerializedSignature) -> bool { *self == **other }
-}
-
-impl PartialOrd for SerializedSignature {
-    fn partial_cmp(&self, other: &SerializedSignature) -> Option<core::cmp::Ordering> {
-        Some((**self).cmp(&**other))
-    }
-}
-
-impl Ord for SerializedSignature {
-    fn cmp(&self, other: &SerializedSignature) -> core::cmp::Ordering { (**self).cmp(&**other) }
-}
-
-impl PartialOrd<[u8]> for SerializedSignature {
-    fn partial_cmp(&self, other: &[u8]) -> Option<core::cmp::Ordering> {
-        (**self).partial_cmp(other)
-    }
-}
-
-impl PartialOrd<SerializedSignature> for [u8] {
-    fn partial_cmp(&self, other: &SerializedSignature) -> Option<core::cmp::Ordering> {
-        self.partial_cmp(&**other)
-    }
-}
-
-impl core::hash::Hash for SerializedSignature {
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) { (**self).hash(state) }
-}
-
-impl AsRef<[u8]> for SerializedSignature {
-    #[inline]
-    fn as_ref(&self) -> &[u8] { self }
-}
-
-impl Borrow<[u8]> for SerializedSignature {
-    #[inline]
-    fn borrow(&self) -> &[u8] { self }
-}
-
-impl ops::Deref for SerializedSignature {
-    type Target = [u8];
-
-    #[inline]
-    fn deref(&self) -> &[u8] { &self.data[..self.len] }
-}
-
-impl Eq for SerializedSignature {}
-
-impl IntoIterator for SerializedSignature {
-    type IntoIter = IntoIter;
-    type Item = u8;
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter { IntoIter::new(self) }
-}
-
-impl<'a> IntoIterator for &'a SerializedSignature {
-    type IntoIter = core::slice::Iter<'a, u8>;
-    type Item = &'a u8;
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter { self.iter() }
-}
-
-impl From<Signature> for SerializedSignature {
-    fn from(value: Signature) -> Self { Self::from_signature(value) }
-}
-
-impl<'a> From<&'a Signature> for SerializedSignature {
-    fn from(value: &'a Signature) -> Self { Self::from_signature(*value) }
-}
-
-impl TryFrom<SerializedSignature> for Signature {
-    type Error = SigFromSliceError;
-
-    fn try_from(value: SerializedSignature) -> Result<Self, Self::Error> { value.to_signature() }
-}
-
-impl<'a> TryFrom<&'a SerializedSignature> for Signature {
-    type Error = SigFromSliceError;
-
-    fn try_from(value: &'a SerializedSignature) -> Result<Self, Self::Error> {
-        value.to_signature()
-    }
-}
-
-impl SerializedSignature {
-    /// Constructs new `SerializedSignature` from data and length.
-    ///
-    /// # Panics
-    ///
-    /// If `len` > `MAX_LEN`
-    #[inline]
-    pub(crate) fn from_raw_parts(data: [u8; MAX_LEN], len: usize) -> Self {
-        assert!(len <= MAX_LEN, "attempt to set length to {} but the maximum is {}", len, MAX_LEN);
-        SerializedSignature { data, len }
-    }
-
-    /// Get the len of the used data.
-    // `len` is never 0, so `is_empty` would always return `false`.
-    #[allow(clippy::len_without_is_empty)]
-    #[inline]
-    pub fn len(&self) -> usize { self.len }
-
-    /// Set the length of the object.
-    #[inline]
-    pub(crate) fn set_len_unchecked(&mut self, len: usize) { self.len = len; }
-
-    /// Convert the serialized signature into the Signature struct.
-    /// (This deserializes it)
-    #[inline]
-    pub fn to_signature(self) -> Result<Signature, SigFromSliceError> {
-        Signature::from_slice(&self)
-    }
-
-    /// Constructs a new SerializedSignature from a Signature.
-    /// (this serializes it)
-    #[inline]
-    pub fn from_signature(sig: Signature) -> SerializedSignature { sig.serialize() }
-
-    /// Writes this serialized signature to a `writer`.
-    #[inline]
-    pub fn write_to<W: Write + ?Sized>(&self, writer: &mut W) -> Result<(), io::Error> {
-        writer.write_all(self)
-    }
-}
-
-/// Separate mod to prevent outside code from accidentally breaking invariants.
-mod into_iter {
-    use super::*;
-
-    /// Owned iterator over the bytes of [`SerializedSignature`]
-    ///
-    /// Created by [`IntoIterator::into_iter`] method.
-    // allowed because of https://github.com/rust-lang/rust/issues/98348
-    #[allow(missing_copy_implementations)]
-    #[derive(Debug, Clone)]
-    pub struct IntoIter {
-        signature: SerializedSignature,
-        // invariant: pos <= signature.len()
-        pos: usize,
-    }
-
-    impl IntoIter {
-        #[inline]
-        pub(crate) fn new(signature: SerializedSignature) -> Self {
-            IntoIter {
-                signature,
-                // for all unsigned n: 0 <= n
-                pos: 0,
-            }
-        }
-
-        /// Returns the remaining bytes as a slice.
-        ///
-        /// This method is analogous to [`core::slice::Iter::as_slice`].
-        #[inline]
-        pub fn as_slice(&self) -> &[u8] { &self.signature[self.pos..] }
-    }
-
-    impl Iterator for IntoIter {
-        type Item = u8;
-
-        #[inline]
-        fn next(&mut self) -> Option<Self::Item> {
-            let byte = *self.signature.get(self.pos)?;
-            // can't overflow or break invariant because if pos is too large we return early
-            self.pos += 1;
-            Some(byte)
-        }
-
-        #[inline]
-        fn size_hint(&self) -> (usize, Option<usize>) {
-            // can't overflow thanks to the invariant
-            let len = self.signature.len() - self.pos;
-            (len, Some(len))
-        }
-
-        // override for speed
-        #[inline]
-        fn nth(&mut self, n: usize) -> Option<Self::Item> {
-            if n >= self.len() {
-                // upholds invariant because the values will be equal
-                self.pos = self.signature.len();
-                None
-            } else {
-                // if n < signature.len() - self.pos then n + self.pos < signature.len() which neither
-                // overflows nor breaks the invariant
-                self.pos += n;
-                self.next()
-            }
-        }
-    }
-
-    impl ExactSizeIterator for IntoIter {}
-
-    impl core::iter::FusedIterator for IntoIter {}
-
-    impl DoubleEndedIterator for IntoIter {
-        #[inline]
-        fn next_back(&mut self) -> Option<Self::Item> {
-            if self.pos == self.signature.len() {
-                return None;
-            }
-
-            // if len is 0 then pos is also 0 thanks to the invariant so we would return before we
-            // reach this
-            let new_len = self.signature.len() - 1;
-            let byte = self.signature[new_len];
-            self.signature.set_len_unchecked(new_len);
-            Some(byte)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{SerializedSignature, MAX_LEN};
-
-    #[test]
-    fn iterator_ops_are_homomorphic() {
-        let mut fake_signature_data = [0; MAX_LEN];
-        for (i, byte) in fake_signature_data.iter_mut().enumerate() {
-            *byte = i as u8;
-        }
-
-        let fake_signature = SerializedSignature { data: fake_signature_data, len: MAX_LEN };
-
-        let mut iter1 = fake_signature.into_iter();
-        let mut iter2 = fake_signature.iter();
-
-        // while let so we can compare size_hint and as_slice
-        while let (Some(a), Some(b)) = (iter1.next(), iter2.next()) {
-            assert_eq!(a, *b);
-            assert_eq!(iter1.size_hint(), iter2.size_hint());
-            assert_eq!(iter1.as_slice(), iter2.as_slice());
-        }
-
-        let mut iter1 = fake_signature.into_iter();
-        let mut iter2 = fake_signature.iter();
-
-        // manual next_back instead of rev() so that we can check as_slice()
-        // if next_back is implemented correctly then rev() is also correct - provided by `core`
-        while let (Some(a), Some(b)) = (iter1.next_back(), iter2.next_back()) {
-            assert_eq!(a, *b);
-            assert_eq!(iter1.size_hint(), iter2.size_hint());
-            assert_eq!(iter1.as_slice(), iter2.as_slice());
-        }
-    }
-}
diff --git a/bitcoin/tests/bip_174.rs b/bitcoin/tests/bip_174.rs
index 10fb81acf9..edcee7418e 100644
--- a/bitcoin/tests/bip_174.rs
+++ b/bitcoin/tests/bip_174.rs
@@ -3,16 +3,16 @@
 
 use std::collections::BTreeMap;
 
+use bitcoin::amount::{Amount, Denomination};
 use bitcoin::bip32::{Fingerprint, IntoDerivationPath, KeySource, Xpriv, Xpub};
 use bitcoin::consensus::encode::{deserialize, serialize_hex};
 use bitcoin::hex::FromHex;
-use bitcoin::opcodes::OP_0;
+use bitcoin::opcodes::all::OP_0;
 use bitcoin::psbt::{Psbt, PsbtSighashType};
-use bitcoin::script::{PushBytes, ScriptBufExt as _};
-use bitcoin::secp256k1::Secp256k1;
+use bitcoin::script::{PushBytes, ScriptBuf, ScriptBufExt as _};
 use bitcoin::{
-    absolute, script, transaction, Amount, Denomination, NetworkKind, OutPoint, PrivateKey,
-    PublicKey, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Witness,
+    absolute, script, transaction, NetworkKind, OutPoint, PrivateKey, PublicKey, ScriptPubKeyBuf,
+    ScriptSigBuf, Sequence, Transaction, TxIn, TxOut, Witness,
 };
 
 #[track_caller]
@@ -22,20 +22,18 @@ fn hex_psbt(s: &str) -> Psbt {
 }
 
 #[track_caller]
-fn hex_script(s: &str) -> ScriptBuf {
+fn hex_script<T>(s: &str) -> ScriptBuf<T> {
     ScriptBuf::from_hex_no_length_prefix(s).expect("valid hex digits")
 }
 
 #[test]
 fn bip174_psbt_workflow() {
-    let secp = Secp256k1::new();
-
     //
     // Step 0: Create the extended private key from the test vector data.
     //
 
     let ext_priv = build_extended_private_key();
-    let ext_pub = Xpub::from_xpriv(&secp, &ext_priv);
+    let ext_pub = Xpub::from_xpriv(&ext_priv);
     let parent_fingerprint = ext_pub.fingerprint();
 
     //
@@ -122,7 +120,7 @@ fn build_extended_private_key() -> Xpriv {
     let xpriv = extended_private_key.parse::<Xpriv>().unwrap();
 
     let sk = PrivateKey::from_wif(seed).unwrap();
-    let seeded = Xpriv::new_master(NetworkKind::Test, &sk.inner.secret_bytes());
+    let seeded = Xpriv::new_master(NetworkKind::Test, &sk.inner.to_secret_bytes());
     assert_eq!(xpriv, seeded);
 
     xpriv
@@ -159,13 +157,13 @@ fn create_transaction() -> Transaction {
     Transaction {
         version: transaction::Version::TWO,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![
+        inputs: vec![
             TxIn {
                 previous_output: OutPoint {
                     txid: input_0.txid.parse().expect("failed to parse txid"),
                     vout: input_0.index,
                 },
-                script_sig: ScriptBuf::new(),
+                script_sig: ScriptSigBuf::new(),
                 sequence: Sequence::MAX, // Disable nSequence.
                 witness: Witness::default(),
             },
@@ -174,22 +172,22 @@ fn create_transaction() -> Transaction {
                     txid: input_1.txid.parse().expect("failed to parse txid"),
                     vout: input_1.index,
                 },
-                script_sig: ScriptBuf::new(),
+                script_sig: ScriptSigBuf::new(),
                 sequence: Sequence::MAX,
                 witness: Witness::default(),
             },
         ],
-        output: vec![
+        outputs: vec![
             TxOut {
-                value: Amount::from_str_in(output_0.amount, Denomination::Bitcoin)
+                amount: Amount::from_str_in(output_0.amount, Denomination::Bitcoin)
                     .expect("failed to parse amount"),
-                script_pubkey: ScriptBuf::from_hex_no_length_prefix(output_0.script_pubkey)
+                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(output_0.script_pubkey)
                     .expect("failed to parse script"),
             },
             TxOut {
-                value: Amount::from_str_in(output_1.amount, Denomination::Bitcoin)
+                amount: Amount::from_str_in(output_1.amount, Denomination::Bitcoin)
                     .expect("failed to parse amount"),
-                script_pubkey: ScriptBuf::from_hex_no_length_prefix(output_1.script_pubkey)
+                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(output_1.script_pubkey)
                     .expect("failed to parse script"),
             },
         ],
@@ -245,7 +243,7 @@ fn update_psbt(mut psbt: Psbt, fingerprint: Fingerprint) -> Psbt {
 
     let v = Vec::from_hex(previous_tx_0).unwrap();
     let tx: Transaction = deserialize(&v).unwrap();
-    input_1.witness_utxo = Some(tx.output[1].clone());
+    input_1.witness_utxo = Some(tx.outputs[1].clone());
 
     input_1.redeem_script = Some(hex_script(redeem_script_1));
     input_1.witness_script = Some(hex_script(witness_script));
@@ -309,8 +307,6 @@ fn parse_and_verify_keys(
     ext_priv: &Xpriv,
     sk_path: &[(&str, &str)],
 ) -> BTreeMap<PublicKey, PrivateKey> {
-    let secp = &Secp256k1::new();
-
     let mut key_map = BTreeMap::new();
     for (secret_key, derivation_path) in sk_path.iter() {
         let wif_priv = PrivateKey::from_wif(secret_key).expect("failed to parse key");
@@ -318,9 +314,9 @@ fn parse_and_verify_keys(
         let path =
             derivation_path.into_derivation_path().expect("failed to convert derivation path");
         let derived_priv =
-            ext_priv.derive_xpriv(secp, &path).expect("derivation path too long").to_private_key();
+            ext_priv.derive_xpriv(&path).expect("derivation path too long").to_private_key();
         assert_eq!(wif_priv, derived_priv);
-        let derived_pub = derived_priv.public_key(secp);
+        let derived_pub = derived_priv.public_key();
         key_map.insert(derived_pub, derived_priv);
     }
     key_map
@@ -410,8 +406,7 @@ fn combine_lexicographically() {
 
 /// Signs `psbt` with `keys` if required.
 fn sign(mut psbt: Psbt, keys: BTreeMap<bitcoin::PublicKey, PrivateKey>) -> Psbt {
-    let secp = Secp256k1::new();
-    psbt.sign(&keys, &secp).unwrap();
+    psbt.sign(&keys).unwrap();
     psbt
 }
 
diff --git a/bitcoin/tests/data/serde/block_bincode b/bitcoin/tests/data/serde/block_bincode
deleted file mode 100644
index 0bd56c8d21..0000000000
Binary files a/bitcoin/tests/data/serde/block_bincode and /dev/null differ
diff --git a/bitcoin/tests/data/serde/out_point_bincode b/bitcoin/tests/data/serde/out_point_bincode
new file mode 100644
index 0000000000..6e8c0a517b
Binary files /dev/null and b/bitcoin/tests/data/serde/out_point_bincode differ
diff --git a/bitcoin/tests/data/serde/proprietary_key_bincode b/bitcoin/tests/data/serde/proprietary_key_bincode
deleted file mode 100644
index 8c0100713b..0000000000
Binary files a/bitcoin/tests/data/serde/proprietary_key_bincode and /dev/null differ
diff --git a/bitcoin/tests/data/serde/psbt_base64.json b/bitcoin/tests/data/serde/psbt_base64.json
new file mode 100644
index 0000000000..d051551779
--- /dev/null
+++ b/bitcoin/tests/data/serde/psbt_base64.json
@@ -0,0 +1 @@
+"cHNidP8BAFMBAAAAATkUkZZWjQ4TAMqaOkez2dl2+5yBsfd38qS6x8fkjesmAQAAAAD/////AXL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAAAAAE8BBIiyHgAAAAAAAAAAAIc9/4HAL1JWI/0f5RZ+rDpVoEnePTFLtC7iJ//tN9UIAzmjYBMwFZfa70H75ZOgLMUT0LVVJ+wt8QUOLo/0nIXCDN6tvu8AAACAAQAAABD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFAAEAjwEAAAAAAQGJo8ceq00g4Dcbu6TMaY+ilclGOvouOX+FM8y2L5Vn5QEAAAAXFgAUvhjRUqmwEgOdrz2n3k9TNJ7suYX/////AXL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUAAAAAAQEgcv74TiwAAAAXqRQzlyW6Ie/WKsdTqbzQZ9bHpqOdBYciAgM5iA3JI5S3NV49BDn6KDwx3nWQgS6gEcQkXAZ0poXog0cwRAIgT2fir7dhQtRPrliiSV0zo0GdqibNDbjQTzRStjKJrA8CIBB2Kp+2fpTMXK2QJvbcmf9/Bw9CeNMPvH0Mhp3TjH/nAQEDBIMAAAABBAFRIgYDOYgNySOUtzVePQQ5+ig8Md51kIEuoBHEJFwGdKaF6IMM3q2+7wAAAIABAAAAAQgGAgIBAwEFFQoYn3yLGjhv/o7tkbODDHp7zR53jAIBAiELoShx/uIQ+4YZKR6uoZRYHL0lMeSyN1nSJfaAaSP2MiICAQIVDBXMSeGRy8Ug2RlEYApct3r2qjKRAgECIQ12pWrO2RXSUT3NhMLDeLLoqlzWMrW3HKLyrFsOOmSb2wIBAhD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFACICAzmIDckjlLc1Xj0EOfooPDHedZCBLqARxCRcBnSmheiDDN6tvu8AAACAAQAAABD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFAA=="
\ No newline at end of file
diff --git a/bitcoin/tests/data/serde/psbt_bincode b/bitcoin/tests/data/serde/psbt_bincode
index 2c352b99c3..0423835c0e 100644
Binary files a/bitcoin/tests/data/serde/psbt_bincode and b/bitcoin/tests/data/serde/psbt_bincode differ
diff --git a/bitcoin/tests/data/serde/raw_pair_bincode b/bitcoin/tests/data/serde/raw_pair_bincode
deleted file mode 100644
index bf1d3218ac..0000000000
Binary files a/bitcoin/tests/data/serde/raw_pair_bincode and /dev/null differ
diff --git a/bitcoin/tests/data/serde/relative_lock_time_blocks_bincode b/bitcoin/tests/data/serde/relative_lock_time_blocks_bincode
index 4eb84bb459..167e25d50c 100644
Binary files a/bitcoin/tests/data/serde/relative_lock_time_blocks_bincode and b/bitcoin/tests/data/serde/relative_lock_time_blocks_bincode differ
diff --git a/bitcoin/tests/data/serde/relative_lock_time_seconds_bincode b/bitcoin/tests/data/serde/relative_lock_time_seconds_bincode
index b6ed9a62a7..53442e8bb2 100644
Binary files a/bitcoin/tests/data/serde/relative_lock_time_seconds_bincode and b/bitcoin/tests/data/serde/relative_lock_time_seconds_bincode differ
diff --git a/bitcoin/tests/data/serde/transaction_bincode b/bitcoin/tests/data/serde/transaction_bincode
deleted file mode 100644
index 82ffd66a79..0000000000
Binary files a/bitcoin/tests/data/serde/transaction_bincode and /dev/null differ
diff --git a/bitcoin/tests/data/serde/txin_bincode b/bitcoin/tests/data/serde/txin_bincode
deleted file mode 100644
index 92a61a1a26..0000000000
Binary files a/bitcoin/tests/data/serde/txin_bincode and /dev/null differ
diff --git a/bitcoin/tests/data/serde/txout_bincode b/bitcoin/tests/data/serde/txout_bincode
deleted file mode 100644
index 1bbd8c3317..0000000000
Binary files a/bitcoin/tests/data/serde/txout_bincode and /dev/null differ
diff --git a/bitcoin/tests/network.rs b/bitcoin/tests/network.rs
new file mode 100644
index 0000000000..2b27272179
--- /dev/null
+++ b/bitcoin/tests/network.rs
@@ -0,0 +1,65 @@
+//! Tests what a user can do when pattern matching on `Network` and associated types.
+
+use bitcoin::network::{Network, NetworkKind, TestnetVersion};
+
+#[test]
+fn can_match_exhaustively_on_network() {
+    // Returns true if `n` is mainnet.
+    fn is_mainnet(n: Network) -> bool { matches!(n, Network::Bitcoin) }
+
+    assert!(is_mainnet(Network::Bitcoin));
+}
+
+#[test]
+fn can_match_exhaustively_on_testnet() {
+    // Returns true if `n` is any testnet.
+    fn is_testnet(n: Network) -> bool { matches!(n, Network::Testnet(_)) }
+
+    assert!(is_testnet(Network::Testnet(TestnetVersion::V3)));
+}
+
+#[test]
+fn can_use_network_kind() {
+    // Returns true if `n` is any mainnet.
+    fn is_mainnet(n: Network) -> bool { NetworkKind::from(n).is_mainnet() }
+
+    // Returns true if `n` is a any testnet.
+    fn is_testnet(n: Network) -> bool { !NetworkKind::from(n).is_mainnet() }
+
+    assert!(is_mainnet(Network::Bitcoin));
+    assert!(!is_testnet(Network::Bitcoin));
+
+    assert!(is_testnet(Network::Testnet(TestnetVersion::V3)));
+    assert!(!is_mainnet(Network::Testnet(TestnetVersion::V3)));
+}
+
+#[test]
+fn can_not_match_exhaustively_on_testnet_version() {
+    // Returns true if `n` is testnet version 3.
+    fn is_testnet_v3(n: Network) -> bool {
+        match n {
+            Network::Testnet(TestnetVersion::V3) => true,
+            Network::Testnet(TestnetVersion::V4) => false,
+            // Catchall because of `non_exhaustive` attribute.
+            Network::Testnet(_) => false,
+            _ => false,
+        }
+    }
+
+    assert!(is_testnet_v3(Network::Testnet(TestnetVersion::V3)));
+}
+
+#[test]
+fn can_match_on_testnet_version_3_only() {
+    // Returns true if `n` is testnet version 3.
+    fn is_testnet_v3(n: Network) -> bool {
+        match n {
+            Network::Testnet(TestnetVersion::V3) => true,
+            // Catchall because its logically correct to do so.
+            Network::Testnet(_) => false,
+            _ => false,
+        }
+    }
+
+    assert!(is_testnet_v3(Network::Testnet(TestnetVersion::V3)));
+}
diff --git a/bitcoin/tests/psbt-sign-taproot.rs b/bitcoin/tests/psbt-sign-taproot.rs
index e692cb1b5b..294d9276cc 100644
--- a/bitcoin/tests/psbt-sign-taproot.rs
+++ b/bitcoin/tests/psbt-sign-taproot.rs
@@ -1,4 +1,6 @@
-#![cfg(not(feature = "rand-std"))]
+//! This test is excluded when the `rand` feature is enabled because Schnorr signatures use
+//! auxiliary randomness, making them non-deterministic and incompatible with hardcoded test vectors.
+#![cfg(all(feature = "std", not(feature = "rand")))]
 
 use std::collections::BTreeMap;
 
@@ -6,15 +8,14 @@ use bitcoin::bip32::{DerivationPath, Fingerprint};
 use bitcoin::consensus::encode::serialize_hex;
 use bitcoin::opcodes::all::OP_CHECKSIG;
 use bitcoin::psbt::{GetKey, Input, KeyRequest, PsbtSighashType, SignError};
-use bitcoin::script::ScriptExt as _;
+use bitcoin::script::TapScriptExt as _;
 use bitcoin::taproot::{LeafVersion, TaprootBuilder, TaprootSpendInfo};
 use bitcoin::transaction::Version;
 use bitcoin::{
-    absolute, script, Address, Network, OutPoint, PrivateKey, Psbt, ScriptBuf, Sequence,
-    Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
+    absolute, script, Address, Amount, Network, OutPoint, PrivateKey, Psbt, ScriptSigBuf, Sequence,
+    TapScriptBuf, Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
 };
-use secp256k1::{Keypair, Secp256k1, Signing};
-use units::Amount;
+use secp256k1::Keypair;
 
 #[test]
 fn psbt_sign_taproot() {
@@ -25,11 +26,7 @@ fn psbt_sign_taproot() {
 
     impl GetKey for Keystore {
         type Error = SignError;
-        fn get_key<C: Signing>(
-            &self,
-            key_request: &KeyRequest,
-            _secp: &Secp256k1<C>,
-        ) -> Result<Option<PrivateKey>, Self::Error> {
+        fn get_key(&self, key_request: &KeyRequest) -> Result<Option<PrivateKey>, Self::Error> {
             match key_request {
                 KeyRequest::Bip32((mfp, _)) =>
                     if *mfp == self.mfp {
@@ -42,8 +39,6 @@ fn psbt_sign_taproot() {
         }
     }
 
-    let secp = &Secp256k1::new();
-
     let sk_path = [
         ("dff1c8c2c016a572914b4c5adb8791d62b4768ae9d0a61be8ab94cf5038d7d90", "m/86'/1'/0'/0/0"),
         ("1ede31b0e7e47c2afc65ffd158b1b1b9d3b752bba8fd117dc8b9e944a390e8d9", "m/86'/1'/0'/0/1"),
@@ -56,17 +51,16 @@ fn psbt_sign_taproot() {
     //
 
     // Create three basic scripts to test script path spend.
-    let script1 = create_basic_single_sig_script(secp, sk_path[0].0); // m/86'/1'/0'/0/0
-    let script2 = create_basic_single_sig_script(secp, sk_path[1].0); // m/86'/1'/0'/0/1
-    let script3 = create_basic_single_sig_script(secp, sk_path[2].0); // m/86'/1'/0'/0/2
+    let script1 = create_basic_single_sig_script(sk_path[0].0); // m/86'/1'/0'/0/0
+    let script2 = create_basic_single_sig_script(sk_path[1].0); // m/86'/1'/0'/0/1
+    let script3 = create_basic_single_sig_script(sk_path[2].0); // m/86'/1'/0'/0/2
 
     // Just use one of the secret keys for the key path spend.
-    let kp = Keypair::from_seckey_str(secp, sk_path[2].0).expect("failed to create keypair");
+    let kp = sk_path[2].0.parse::<Keypair>().expect("failed to create keypair");
 
     let internal_key = kp.x_only_public_key().0; // Ignore the parity.
 
-    let tree =
-        create_taproot_tree(secp, script1.clone(), script2.clone(), script3.clone(), internal_key);
+    let tree = create_taproot_tree(script1, script2.clone(), script3, internal_key);
 
     let address = create_p2tr_address(tree.clone());
     assert_eq!(
@@ -93,7 +87,7 @@ fn psbt_sign_taproot() {
             mfp: mfp.parse::<Fingerprint>().unwrap(),
             sk: PrivateKey::new(kp.secret_key(), Network::Testnet(bitcoin::TestnetVersion::V3)),
         };
-        let _ = psbt_key_path_spend.sign(&keystore, secp);
+        let _ = psbt_key_path_spend.sign(&keystore);
 
         let sig = "92864dc9e56b6260ecbd54ec16b94bb597a2e6be7cca0de89d75e17921e0e1528cba32dd04217175c237e1835b5db1c8b384401718514f9443dce933c6ba9c87";
         assert_eq!(sig, psbt_key_path_spend.inputs[0].tap_key_sig.unwrap().signature.to_string());
@@ -115,7 +109,7 @@ fn psbt_sign_taproot() {
     // script path spend
     {
         // use private key of path "m/86'/1'/0'/0/1" as signing key
-        let kp = Keypair::from_seckey_str(secp, sk_path[1].0).expect("failed to create keypair");
+        let kp = sk_path[1].0.parse::<Keypair>().expect("failed to create keypair");
         let x_only_pubkey = kp.x_only_public_key().0;
         let signing_key_path = sk_path[1].1;
 
@@ -130,7 +124,7 @@ fn psbt_sign_taproot() {
         let mut psbt_script_path_spend = create_psbt_for_taproot_script_path_spend(
             address,
             to_address,
-            tree.clone(),
+            tree,
             x_only_pubkey,
             signing_key_path,
             script2.clone(),
@@ -139,14 +133,14 @@ fn psbt_sign_taproot() {
         //
         // Step 2: sign psbt.
         //
-        let _ = psbt_script_path_spend.sign(&keystore, secp);
+        let _ = psbt_script_path_spend.sign(&keystore);
 
         let sig = "9c1466e1631a58c55fcb8642ce5f7896314f4b565d92c5c80b17aa9abf56d22e0b5e5dcbcfe836bbd7d409491f58aa9e1f68a491ef8f05eef62fb50ffac85727";
         assert_eq!(
             sig,
             psbt_script_path_spend.inputs[0]
                 .tap_script_sigs
-                .get(&(x_only_pubkey.into(), script2.clone().tapscript_leaf_hash()))
+                .get(&(x_only_pubkey.into(), script2.tapscript_leaf_hash()))
                 .unwrap()
                 .signature
                 .to_string()
@@ -167,8 +161,8 @@ fn psbt_sign_taproot() {
     }
 }
 
-fn create_basic_single_sig_script(secp: &Secp256k1<secp256k1::All>, sk: &str) -> ScriptBuf {
-    let kp = Keypair::from_seckey_str(secp, sk).expect("failed to create keypair");
+fn create_basic_single_sig_script(sk: &str) -> TapScriptBuf {
+    let kp = sk.parse::<Keypair>().expect("failed to create keypair");
     let x_only_pubkey = kp.x_only_public_key().0;
     script::Builder::new()
         .push_slice(x_only_pubkey.serialize())
@@ -177,10 +171,9 @@ fn create_basic_single_sig_script(secp: &Secp256k1<secp256k1::All>, sk: &str) ->
 }
 
 fn create_taproot_tree<K: Into<XOnlyPublicKey>>(
-    secp: &Secp256k1<secp256k1::All>,
-    script1: ScriptBuf,
-    script2: ScriptBuf,
-    script3: ScriptBuf,
+    script1: TapScriptBuf,
+    script2: TapScriptBuf,
+    script3: TapScriptBuf,
     internal_key: K,
 ) -> TaprootSpendInfo {
     let internal_key = internal_key.into();
@@ -188,7 +181,7 @@ fn create_taproot_tree<K: Into<XOnlyPublicKey>>(
     let builder = builder.add_leaf(2, script1).unwrap();
     let builder = builder.add_leaf(2, script2).unwrap();
     let builder = builder.add_leaf(1, script3).unwrap();
-    builder.finalize(secp, internal_key).unwrap()
+    builder.finalize(internal_key).unwrap()
 }
 
 fn create_p2tr_address(tree: TaprootSpendInfo) -> Address {
@@ -201,9 +194,9 @@ fn create_psbt_for_taproot_key_path_spend(
     to_address: Address,
     tree: TaprootSpendInfo,
 ) -> Psbt {
-    let send_value = 6400;
+    let send_amount = 6400;
     let out_puts = vec![TxOut {
-        value: Amount::from_sat(send_value).unwrap(),
+        amount: Amount::from_sat(send_amount).unwrap(),
         script_pubkey: to_address.script_pubkey(),
     }];
     let prev_tx_id = "06980ca116f74c7845a897461dd0e1d15b114130176de5004957da516b4dee3a";
@@ -211,13 +204,13 @@ fn create_psbt_for_taproot_key_path_spend(
     let transaction = Transaction {
         version: Version::TWO,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![TxIn {
+        inputs: vec![TxIn {
             previous_output: OutPoint { txid: prev_tx_id.parse().unwrap(), vout: 0 },
-            script_sig: ScriptBuf::new(),
+            script_sig: ScriptSigBuf::new(),
             sequence: Sequence(0xFFFFFFFF), // Ignore nSequence.
             witness: Witness::default(),
         }],
-        output: out_puts,
+        outputs: out_puts,
     };
 
     let mut psbt = Psbt::from_unsigned_tx(transaction).unwrap();
@@ -237,11 +230,11 @@ fn create_psbt_for_taproot_key_path_spend(
         ),
     );
 
-    let utxo_value = 6588;
+    let utxo_amount = 6588;
     let mut input = Input {
         witness_utxo: {
             let script_pubkey = from_address.script_pubkey();
-            Some(TxOut { value: Amount::from_sat(utxo_value).unwrap(), script_pubkey })
+            Some(TxOut { amount: Amount::from_sat(utxo_amount).unwrap(), script_pubkey })
         },
         tap_key_origins: origins,
         ..Default::default()
@@ -274,28 +267,28 @@ fn create_psbt_for_taproot_script_path_spend<K: Into<XOnlyPublicKey>>(
     tree: TaprootSpendInfo,
     x_only_pubkey_of_signing_key: K,
     signing_key_path: &str,
-    use_script: ScriptBuf,
+    use_script: TapScriptBuf,
 ) -> Psbt {
     let x_only_pubkey_of_signing_key = x_only_pubkey_of_signing_key.into();
-    let utxo_value = 6280;
-    let send_value = 6000;
+    let utxo_amount = 6280;
+    let send_amount = 6000;
     let mfp = "73c5da0a";
 
     let out_puts = vec![TxOut {
-        value: Amount::from_sat(send_value).unwrap(),
+        amount: Amount::from_sat(send_amount).unwrap(),
         script_pubkey: to_address.script_pubkey(),
     }];
     let prev_tx_id = "9d7c6770fca57285babab60c51834cfcfd10ad302119cae842d7216b4ac9a376";
     let transaction = Transaction {
         version: Version::TWO,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![TxIn {
+        inputs: vec![TxIn {
             previous_output: OutPoint { txid: prev_tx_id.parse().unwrap(), vout: 0 },
-            script_sig: ScriptBuf::new(),
+            script_sig: ScriptSigBuf::new(),
             sequence: Sequence(0xFFFFFFFF), // Ignore nSequence.
             witness: Witness::default(),
         }],
-        output: out_puts,
+        outputs: out_puts,
     };
 
     let mut psbt = Psbt::from_unsigned_tx(transaction).unwrap();
@@ -315,13 +308,13 @@ fn create_psbt_for_taproot_script_path_spend<K: Into<XOnlyPublicKey>>(
     let mut tap_scripts = BTreeMap::new();
     tap_scripts.insert(
         tree.control_block(&(use_script.clone(), LeafVersion::TapScript)).unwrap(),
-        (use_script.clone(), LeafVersion::TapScript),
+        (use_script, LeafVersion::TapScript),
     );
 
     let mut input = Input {
         witness_utxo: {
             let script_pubkey = from_address.script_pubkey();
-            Some(TxOut { value: Amount::from_sat(utxo_value).unwrap(), script_pubkey })
+            Some(TxOut { amount: Amount::from_sat(utxo_amount).unwrap(), script_pubkey })
         },
         tap_key_origins: origins,
         tap_scripts,
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index f9e7e4a6a3..213555a399 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -8,14 +8,11 @@
 //! Types/tests were found using, and are ordered by, the output of: `git grep -l Serialize`.
 //!
 
-// In tests below `deserialize` is consensus deserialize while `serialize` is serde serialize, that
-// is why we have two different serialized data files for tests that use binary serialized input.
-//
 // To create a file with the expected serialized data do something like:
 //
 //  use std::fs::File;
 //  use std::io::Write;
-//  let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+//  let script = WitnessScriptBuf::from(vec![0u8, 1u8, 2u8]);
 //  let got = serialize(&script).unwrap();
 //  let mut file = File::create("/tmp/script_bincode").unwrap();
 //  file.write_all(&got).unwrap();
@@ -26,36 +23,24 @@ use std::collections::BTreeMap;
 
 use bincode::serialize;
 use bitcoin::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
-use bitcoin::consensus::encode::deserialize;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 use bitcoin::hex::FromHex;
 use bitcoin::locktime::{absolute, relative};
-use bitcoin::psbt::raw::{self, Key, Pair, ProprietaryKey};
-use bitcoin::psbt::{Input, Output, Psbt, PsbtSighashType};
+use bitcoin::psbt::{raw, Input, Output, Psbt, PsbtSighashType};
 use bitcoin::script::ScriptBufExt as _;
 use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::taproot::{self, ControlBlock, LeafVersion, TapTree, TaprootBuilder};
 use bitcoin::witness::Witness;
 use bitcoin::{
-    ecdsa, transaction, Address, Amount, Block, NetworkKind, OutPoint, PrivateKey, PublicKey,
-    ScriptBuf, Sequence, Target, Transaction, TxIn, TxOut, Txid, Work,
+    ecdsa, transaction, Address, Amount, NetworkKind, OutPoint, PrivateKey, PublicKey,
+    ScriptPubKeyBuf, ScriptSigBuf, Sequence, TapScriptBuf, Target, Transaction, TxIn, TxOut, Txid,
+    Work,
 };
 
-/// Implicitly does regression test for `BlockHeader` also.
-#[test]
-fn serde_regression_block() {
-    let segwit = include_bytes!(
-        "data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw"
-    );
-    let block: Block = deserialize(segwit).unwrap();
-    let got = serialize(&block).unwrap();
-    let want = include_bytes!("data/serde/block_bincode");
-    assert_eq!(got, want)
-}
-
 #[test]
 fn serde_regression_absolute_lock_time_height() {
     let t = absolute::LockTime::from_height(741521).expect("valid height");
+
     let got = serialize(&t).unwrap();
     let want = include_bytes!("data/serde/absolute_lock_time_blocks_bincode") as &[_];
     assert_eq!(got, want);
@@ -64,9 +49,9 @@ fn serde_regression_absolute_lock_time_height() {
 #[test]
 fn serde_regression_absolute_lock_time_time() {
     let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
-    let t = absolute::LockTime::from_time(seconds).expect("valid time");
-    let got = serialize(&t).unwrap();
+    let t = absolute::LockTime::from_mtp(seconds).expect("valid time");
 
+    let got = serialize(&t).unwrap();
     let want = include_bytes!("data/serde/absolute_lock_time_seconds_bincode") as &[_];
     assert_eq!(got, want);
 }
@@ -74,8 +59,8 @@ fn serde_regression_absolute_lock_time_time() {
 #[test]
 fn serde_regression_relative_lock_time_height() {
     let t = relative::LockTime::from(relative::Height::from(0xCAFE_u16));
-    let got = serialize(&t).unwrap();
 
+    let got = serialize(&t).unwrap();
     let want = include_bytes!("data/serde/relative_lock_time_blocks_bincode") as &[_];
     assert_eq!(got, want);
 }
@@ -83,44 +68,32 @@ fn serde_regression_relative_lock_time_height() {
 #[test]
 fn serde_regression_relative_lock_time_time() {
     let t = relative::LockTime::from(relative::Time::from_512_second_intervals(0xFACE_u16));
-    let got = serialize(&t).unwrap();
 
+    let got = serialize(&t).unwrap();
     let want = include_bytes!("data/serde/relative_lock_time_seconds_bincode") as &[_];
     assert_eq!(got, want);
 }
 
 #[test]
 fn serde_regression_script() {
-    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+    let script = ScriptSigBuf::from(vec![0u8, 1u8, 2u8]);
+
     let got = serialize(&script).unwrap();
     let want = include_bytes!("data/serde/script_bincode") as &[_];
     assert_eq!(got, want)
 }
 
 #[test]
-fn serde_regression_txin() {
-    let ser = include_bytes!("data/serde/txin_ser");
-    let txin: TxIn = deserialize(ser).unwrap();
-
-    let got = serialize(&txin).unwrap();
-    let want = include_bytes!("data/serde/txin_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_txout() {
-    let txout = TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
-    let got = serialize(&txout).unwrap();
-    let want = include_bytes!("data/serde/txout_bincode") as &[_];
-    assert_eq!(got, want)
-}
+fn serde_regression_out_point() {
+    let out_point = OutPoint {
+        txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
+            .parse::<Txid>()
+            .unwrap(),
+        vout: 1,
+    };
 
-#[test]
-fn serde_regression_transaction() {
-    let ser = include_bytes!("data/serde/transaction_ser");
-    let tx: Transaction = deserialize(ser).unwrap();
-    let got = serialize(&tx).unwrap();
-    let want = include_bytes!("data/serde/transaction_bincode") as &[_];
+    let got = serialize(&out_point).unwrap();
+    let want = include_bytes!("data/serde/out_point_bincode") as &[_];
     assert_eq!(got, want)
 }
 
@@ -152,6 +125,7 @@ fn serde_regression_address() {
 fn serde_regression_extended_priv_key() {
     let s = include_str!("data/serde/extended_priv_key");
     let key = s.trim().parse::<Xpriv>().unwrap();
+
     let got = serialize(&key).unwrap();
     let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_];
     assert_eq!(got, want)
@@ -161,6 +135,7 @@ fn serde_regression_extended_priv_key() {
 fn serde_regression_extended_pub_key() {
     let s = include_str!("data/serde/extended_pub_key");
     let key = s.trim().parse::<Xpub>().unwrap();
+
     let got = serialize(&key).unwrap();
     let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_];
     assert_eq!(got, want)
@@ -183,8 +158,8 @@ fn serde_regression_ecdsa_sig() {
 fn serde_regression_control_block() {
     let s = include_str!("data/serde/control_block_hex");
     let block = ControlBlock::decode(&Vec::<u8>::from_hex(s.trim()).unwrap()).unwrap();
-    let got = serialize(&block).unwrap();
 
+    let got = serialize(&block).unwrap();
     let want = include_bytes!("data/serde/control_block_bincode") as &[_];
     assert_eq!(got, want)
 }
@@ -192,6 +167,7 @@ fn serde_regression_control_block() {
 #[test]
 fn serde_regression_child_number() {
     let num = ChildNumber::Normal { index: 0xDEADBEEF };
+
     let got = serialize(&num).unwrap();
     let want = include_bytes!("data/serde/child_number_bincode") as &[_];
     assert_eq!(got, want)
@@ -200,6 +176,7 @@ fn serde_regression_child_number() {
 #[test]
 fn serde_regression_private_key() {
     let sk = PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
+
     let got = serialize(&sk).unwrap();
     let want = include_bytes!("data/serde/private_key_bincode") as &[_];
     assert_eq!(got, want)
@@ -209,6 +186,7 @@ fn serde_regression_private_key() {
 fn serde_regression_public_key() {
     let s = include_str!("data/serde/public_key_hex");
     let pk = s.trim().parse::<PublicKey>().unwrap();
+
     let got = serialize(&pk).unwrap();
     let want = include_bytes!("data/serde/public_key_bincode") as &[_];
     assert_eq!(got, want)
@@ -219,14 +197,14 @@ fn serde_regression_psbt() {
     let tx = Transaction {
         version: transaction::Version::ONE,
         lock_time: absolute::LockTime::ZERO,
-        input: vec![TxIn {
+        inputs: vec![TxIn {
             previous_output: OutPoint {
                 txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
                     .parse::<Txid>()
                     .unwrap(),
                 vout: 1,
             },
-            script_sig: ScriptBuf::from_hex_no_length_prefix(
+            script_sig: ScriptSigBuf::from_hex_no_length_prefix(
                 "160014be18d152a9b012039daf3da7de4f53349eecb985",
             )
             .unwrap(),
@@ -236,9 +214,9 @@ fn serde_regression_psbt() {
             )
             .unwrap()]),
         }],
-        output: vec![TxOut {
-            value: Amount::from_sat(190_303_501_938).unwrap(),
-            script_pubkey: ScriptBuf::from_hex_no_length_prefix(
+        outputs: vec![TxOut {
+            amount: Amount::from_sat(190_303_501_938).unwrap(),
+            script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix(
                 "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
             )
             .unwrap(),
@@ -276,8 +254,9 @@ fn serde_regression_psbt() {
         },
         unsigned_tx: {
             let mut unsigned = tx.clone();
-            unsigned.input[0].script_sig = ScriptBuf::new();
-            unsigned.input[0].witness = Witness::default();
+            unsigned.inputs[0].previous_output.txid = tx.compute_txid();
+            unsigned.inputs[0].script_sig = ScriptSigBuf::new();
+            unsigned.inputs[0].witness = Witness::default();
             unsigned
         },
         proprietary: proprietary.clone(),
@@ -286,8 +265,8 @@ fn serde_regression_psbt() {
         inputs: vec![Input {
             non_witness_utxo: Some(tx),
             witness_utxo: Some(TxOut {
-                value: Amount::from_sat(190_303_501_938).unwrap(),
-                script_pubkey: ScriptBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                amount: Amount::from_sat(190_303_501_938).unwrap(),
+                script_pubkey: ScriptPubKeyBuf::from_hex_no_length_prefix("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
             }),
             sighash_type: Some(PsbtSighashType::from("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<EcdsaSighashType>().unwrap())),
             redeem_script: Some(vec![0x51].into()),
@@ -314,36 +293,17 @@ fn serde_regression_psbt() {
         }],
     };
 
-    // Sanity, check we can roundtrip BIP-174 serialize.
+    // Sanity, check we can roundtrip BIP-0174 serialize.
     let serialized = psbt.serialize();
     Psbt::deserialize(&serialized).unwrap();
 
     let got = serialize(&psbt).unwrap();
     let want = include_bytes!("data/serde/psbt_bincode") as &[_];
-    assert_eq!(got, want)
-}
-
-#[test]
-fn serde_regression_raw_pair() {
-    let pair = Pair {
-        key: Key { type_value: 1u64, key_data: vec![0u8, 1u8, 2u8, 3u8] },
-        value: vec![0u8, 1u8, 2u8, 3u8],
-    };
-    let got = serialize(&pair).unwrap();
-    let want = include_bytes!("data/serde/raw_pair_bincode") as &[_];
-    assert_eq!(got, want)
-}
+    assert_eq!(got, want);
 
-#[test]
-fn serde_regression_proprietary_key() {
-    let key = ProprietaryKey {
-        prefix: vec![0u8, 1u8, 2u8, 3u8],
-        subtype: 1u64,
-        key: vec![0u8, 1u8, 2u8, 3u8],
-    };
-    let got = serialize(&key).unwrap();
-    let want = include_bytes!("data/serde/proprietary_key_bincode") as &[_];
-    assert_eq!(got, want)
+    let got = serde_json::to_string(&psbt).unwrap();
+    let want = include_str!("data/serde/psbt_base64.json");
+    assert_eq!(got, want);
 }
 
 #[test]
@@ -362,7 +322,7 @@ fn serde_regression_taproot_sig() {
 #[test]
 fn serde_regression_taptree() {
     let ver = LeafVersion::from_consensus(0).unwrap();
-    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+    let script = TapScriptBuf::from(vec![0u8, 1u8, 2u8]);
     let mut builder = TaprootBuilder::new().add_leaf_with_ver(1, script.clone(), ver).unwrap();
     builder = builder.add_leaf(1, script).unwrap();
     let tree = TapTree::try_from(builder).unwrap();
@@ -388,6 +348,7 @@ fn le_bytes() -> [u8; 32] {
 #[test]
 fn serde_regression_work() {
     let work = Work::from_le_bytes(le_bytes());
+
     let got = serialize(&work).unwrap();
     let want = include_bytes!("data/serde/u256_bincode") as &[_];
     assert_eq!(got, want)
@@ -396,6 +357,7 @@ fn serde_regression_work() {
 #[test]
 fn serde_regression_target() {
     let target = Target::from_le_bytes(le_bytes());
+
     let got = serialize(&target).unwrap();
     let want = include_bytes!("data/serde/u256_bincode") as &[_];
     assert_eq!(got, want)
diff --git a/bitcoin/tests/serde_opcodes.rs b/bitcoin/tests/serde_opcodes.rs
index 0b662c521a..a94d3f96c5 100644
--- a/bitcoin/tests/serde_opcodes.rs
+++ b/bitcoin/tests/serde_opcodes.rs
@@ -99,24 +99,24 @@ fn serde_regression_opcodes() {
         OP_PUSHDATA1,
         OP_PUSHDATA2,
         OP_PUSHDATA4,
-        OP_PUSHNUM_NEG1,
+        OP_1NEGATE,
         OP_RESERVED,
-        OP_PUSHNUM_1,
-        OP_PUSHNUM_2,
-        OP_PUSHNUM_3,
-        OP_PUSHNUM_4,
-        OP_PUSHNUM_5,
-        OP_PUSHNUM_6,
-        OP_PUSHNUM_7,
-        OP_PUSHNUM_8,
-        OP_PUSHNUM_9,
-        OP_PUSHNUM_10,
-        OP_PUSHNUM_11,
-        OP_PUSHNUM_12,
-        OP_PUSHNUM_13,
-        OP_PUSHNUM_14,
-        OP_PUSHNUM_15,
-        OP_PUSHNUM_16,
+        OP_1,
+        OP_2,
+        OP_3,
+        OP_4,
+        OP_5,
+        OP_6,
+        OP_7,
+        OP_8,
+        OP_9,
+        OP_10,
+        OP_11,
+        OP_12,
+        OP_13,
+        OP_14,
+        OP_15,
+        OP_16,
         OP_NOP,
         OP_VER,
         OP_IF,
@@ -179,10 +179,10 @@ fn serde_regression_opcodes() {
         OP_NUMEQUAL,
         OP_NUMEQUALVERIFY,
         OP_NUMNOTEQUAL,
-        OP_LESSTHAN ,
-        OP_GREATERTHAN ,
-        OP_LESSTHANOREQUAL ,
-        OP_GREATERTHANOREQUAL ,
+        OP_LESSTHAN,
+        OP_GREATERTHAN,
+        OP_LESSTHANOREQUAL,
+        OP_GREATERTHANOREQUAL,
         OP_MIN,
         OP_MAX,
         OP_WITHIN,
diff --git a/chacha20_poly1305/Cargo.toml b/chacha20_poly1305/Cargo.toml
index daf4391932..8abd82a81e 100644
--- a/chacha20_poly1305/Cargo.toml
+++ b/chacha20_poly1305/Cargo.toml
@@ -9,7 +9,7 @@ categories = ["cryptography"]
 keywords = ["crypto", "encryption"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
@@ -26,3 +26,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)'] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/chacha20_poly1305/README.md b/chacha20_poly1305/README.md
index 259f8f6fc1..7789b0cbf3 100644
--- a/chacha20_poly1305/README.md
+++ b/chacha20_poly1305/README.md
@@ -3,7 +3,3 @@
 An authenticated encryption with associated data (AEAD) algorithm implemented with the ChaCha20 stream cipher and the Poly1305 message authentication code (MAC).
 
 This implementation is maintained by the rust-bitcoin community and has a focus on a bare-bones API suitable for the bitcoin ecosystem.
-
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
diff --git a/chacha20_poly1305/contrib/extra_lints.sh b/chacha20_poly1305/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/chacha20_poly1305/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/chacha20_poly1305/src/benches.rs b/chacha20_poly1305/src/benches.rs
deleted file mode 100644
index ebe086c3f0..0000000000
--- a/chacha20_poly1305/src/benches.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use test::Bencher;
-
-use crate::{ChaCha20, Key, Nonce};
-
-#[bench]
-pub fn chacha20_10(bh: &mut Bencher) {
-    let key = Key::new([0u8; 32]);
-    let nonce = Nonce::new([0u8; 12]);
-    let count = 1;
-    let mut chacha = ChaCha20::new(key, nonce, count);
-    let mut bytes = [0u8; 10];
-    bh.iter(|| {
-        chacha.apply_keystream(&mut bytes[..]);
-    });
-    bh.bytes = bytes.len() as u64;
-}
-
-#[bench]
-pub fn chacha20_1k(bh: &mut Bencher) {
-    let key = Key::new([0u8; 32]);
-    let nonce = Nonce::new([0u8; 12]);
-    let count = 1;
-    let mut chacha = ChaCha20::new(key, nonce, count);
-    let mut bytes = [0u8; 1024];
-    bh.iter(|| {
-        chacha.apply_keystream(&mut bytes[..]);
-    });
-    bh.bytes = bytes.len() as u64;
-}
-
-#[bench]
-pub fn chacha20_64k(bh: &mut Bencher) {
-    let key = Key::new([0u8; 32]);
-    let nonce = Nonce::new([0u8; 12]);
-    let count = 1;
-    let mut chacha = ChaCha20::new(key, nonce, count);
-    let mut bytes = [0u8; 65536];
-    bh.iter(|| {
-        chacha.apply_keystream(&mut bytes[..]);
-    });
-    bh.bytes = bytes.len() as u64;
-}
diff --git a/chacha20_poly1305/src/chacha20.rs b/chacha20_poly1305/src/chacha20.rs
index 3902c7c0f6..13c4f5f407 100644
--- a/chacha20_poly1305/src/chacha20.rs
+++ b/chacha20_poly1305/src/chacha20.rs
@@ -19,7 +19,7 @@ pub struct Key([u8; 32]);
 
 impl Key {
     /// Constructs a new key.
-    pub const fn new(key: [u8; 32]) -> Self { Key(key) }
+    pub const fn new(key: [u8; 32]) -> Self { Self(key) }
 }
 
 /// A 96-bit initialization vector (IV), or nonce.
@@ -28,7 +28,7 @@ pub struct Nonce([u8; 12]);
 
 impl Nonce {
     /// Constructs a new nonce.
-    pub const fn new(nonce: [u8; 12]) -> Self { Nonce(nonce) }
+    pub const fn new(nonce: [u8; 12]) -> Self { Self(nonce) }
 }
 
 // Const validation trait for compile time check with max of 3.
@@ -63,7 +63,7 @@ impl UpTo3<3> for () {}
 ///
 /// In the future, a "blacklist" for the alignment option might be useful to
 /// disable it on architectures which definitely do not support SIMD in order to avoid
-/// needless memory inefficientcies.
+/// needless memory inefficiencies.
 #[derive(Clone, Copy, PartialEq)]
 struct U32x4([u32; 4]);
 
@@ -74,7 +74,7 @@ impl U32x4 {
         (0..4).for_each(|i| {
             result[i] = self.0[i].wrapping_add(rhs.0[i]);
         });
-        U32x4(result)
+        Self(result)
     }
 
     #[inline(always)]
@@ -83,7 +83,7 @@ impl U32x4 {
         (0..4).for_each(|i| {
             result[i] = self.0[i].rotate_left(n);
         });
-        U32x4(result)
+        Self(result)
     }
 
     #[inline(always)]
@@ -92,9 +92,9 @@ impl U32x4 {
         (): UpTo3<N>,
     {
         match N {
-            1 => U32x4([self.0[1], self.0[2], self.0[3], self.0[0]]),
-            2 => U32x4([self.0[2], self.0[3], self.0[0], self.0[1]]),
-            3 => U32x4([self.0[3], self.0[0], self.0[1], self.0[2]]),
+            1 => Self([self.0[1], self.0[2], self.0[3], self.0[0]]),
+            2 => Self([self.0[2], self.0[3], self.0[0], self.0[1]]),
+            3 => Self([self.0[3], self.0[0], self.0[1], self.0[2]]),
             _ => self, // Rotate by 0 is a no-op.
         }
     }
@@ -105,9 +105,9 @@ impl U32x4 {
         (): UpTo3<N>,
     {
         match N {
-            1 => U32x4([self.0[3], self.0[0], self.0[1], self.0[2]]),
-            2 => U32x4([self.0[2], self.0[3], self.0[0], self.0[1]]),
-            3 => U32x4([self.0[1], self.0[2], self.0[3], self.0[0]]),
+            1 => Self([self.0[3], self.0[0], self.0[1], self.0[2]]),
+            2 => Self([self.0[2], self.0[3], self.0[0], self.0[1]]),
+            3 => Self([self.0[1], self.0[2], self.0[3], self.0[0]]),
             _ => self, // Rotate by 0 is a no-op.
         }
     }
@@ -131,7 +131,7 @@ impl BitXor for U32x4 {
         (0..4).for_each(|i| {
             result[i] = self.0[i] ^ rhs.0[i];
         });
-        U32x4(result)
+        Self(result)
     }
 }
 
@@ -165,7 +165,7 @@ impl State {
         let n1 = u32::from_le_bytes([nonce.0[4], nonce.0[5], nonce.0[6], nonce.0[7]]);
         let n2 = u32::from_le_bytes([nonce.0[8], nonce.0[9], nonce.0[10], nonce.0[11]]);
 
-        State {
+        Self {
             matrix: [
                 U32x4([WORD_1, WORD_2, WORD_3, WORD_4]),
                 U32x4([k0, k1, k2, k3]),
@@ -193,7 +193,7 @@ impl State {
         [a, b, c, d]
     }
 
-    /// Perform a round on "columns" and then "diagonals" of the state.
+    /// Performs a round on "columns" and then "diagonals" of the state.
     ///
     /// The column quarter rounds are made up of indexes: `[0,4,8,12]`, `[1,5,9,13]`, `[2,6,10,14]`, `[3,7,11,15]`.
     /// The diagonals quarter rounds are made up of indexes: `[0,5,10,15]`, `[1,6,11,12]`, `[2,7,8,13]`, `[3,4,9,14]`.
@@ -222,7 +222,7 @@ impl State {
         [a, b, c, d]
     }
 
-    /// Transform the state by performing the ChaCha block function.
+    /// Transforms the state by performing the ChaCha block function.
     #[inline(always)]
     fn chacha_block(&mut self) {
         let mut working_state = self.matrix;
@@ -251,7 +251,7 @@ impl State {
 /// The ChaCha20 stream cipher from RFC8439.
 ///
 /// The 20-round IETF version uses a 96-bit nonce and 32-bit block counter. This is the
-/// variant used in the Bitcoin ecosystem, including BIP324.
+/// variant used in the Bitcoin ecosystem, including BIP-0324.
 pub struct ChaCha20 {
     /// Secret key shared by the parties communicating.
     key: Key,
@@ -268,15 +268,15 @@ impl ChaCha20 {
     pub const fn new(key: Key, nonce: Nonce, seek: u32) -> Self {
         let block_count = seek / 64;
         let seek_offset_bytes = (seek % 64) as usize;
-        ChaCha20 { key, nonce, block_count, seek_offset_bytes }
+        Self { key, nonce, block_count, seek_offset_bytes }
     }
 
     /// Make a new instance of ChaCha20 from a block in the keystream.
     pub const fn new_from_block(key: Key, nonce: Nonce, block: u32) -> Self {
-        ChaCha20 { key, nonce, block_count: block, seek_offset_bytes: 0 }
+        Self { key, nonce, block_count: block, seek_offset_bytes: 0 }
     }
 
-    /// Get the keystream for a specific block.
+    /// Gets the keystream for a specific block.
     #[inline(always)]
     fn keystream_at_block(&self, block: u32) -> [u8; 64] {
         let mut state = State::new(self.key, self.nonce, block);
@@ -331,16 +331,16 @@ impl ChaCha20 {
         }
     }
 
-    /// Get the keystream for specified block.
+    /// Gets the keystream for specified block.
     pub fn get_keystream(&self, block: u32) -> [u8; 64] { self.keystream_at_block(block) }
 
-    /// Update the index of the keystream to the given byte.
+    /// Updates the index of the keystream to the given byte.
     pub fn seek(&mut self, seek: u32) {
         self.block_count = seek / 64;
         self.seek_offset_bytes = (seek % 64) as usize;
     }
 
-    /// Update the index of the keystream to a block.
+    /// Updates the index of the keystream to a block.
     pub fn block(&mut self, block: u32) {
         self.block_count = block;
         self.seek_offset_bytes = 0;
diff --git a/chacha20_poly1305/src/lib.rs b/chacha20_poly1305/src/lib.rs
index 045a5b374c..88283d4b13 100644
--- a/chacha20_poly1305/src/lib.rs
+++ b/chacha20_poly1305/src/lib.rs
@@ -1,14 +1,11 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # ChaCha20 - Poly1305
+//! ChaCha20 - Poly1305
 //!
 //! Combine the ChaCha20 stream cipher with the Poly1305 message authentication code
 //! to form an authenticated encryption with additional data (AEAD) algorithm.
 
 #![no_std]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![cfg_attr(bench, feature(test))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
@@ -16,17 +13,13 @@
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
-#[cfg(bench)]
-mod benches;
-#[cfg(bench)]
-extern crate test;
 pub mod chacha20;
 pub mod poly1305;
 
@@ -50,7 +43,7 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::UnauthenticatedAdditionalData => write!(f, "Unauthenticated aad."),
+            Self::UnauthenticatedAdditionalData => write!(f, "Unauthenticated aad."),
         }
     }
 }
@@ -59,12 +52,12 @@ impl fmt::Display for Error {
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            Error::UnauthenticatedAdditionalData => None,
+            Self::UnauthenticatedAdditionalData => None,
         }
     }
 }
 
-/// Encrypt and decrypt content along with a authentication tag.
+/// Encrypt and decrypt content along with an authentication tag.
 pub struct ChaCha20Poly1305 {
     key: Key,
     nonce: Nonce,
@@ -72,14 +65,14 @@ pub struct ChaCha20Poly1305 {
 
 impl ChaCha20Poly1305 {
     /// Make a new instance of a ChaCha20Poly1305 AEAD.
-    pub const fn new(key: Key, nonce: Nonce) -> Self { ChaCha20Poly1305 { key, nonce } }
+    pub const fn new(key: Key, nonce: Nonce) -> Self { Self { key, nonce } }
 
     /// Encrypt content in place and return the Poly1305 16-byte authentication tag.
     ///
     /// # Parameters
     ///
-    /// - `content` - Plaintext to be encrypted in place.
-    /// - `aad`     - Optional metadata covered by the authentication tag.
+    /// - `content` - the plaintext to be encrypted in place.
+    /// - `aad`     - the optional metadata covered by the authentication tag.
     ///
     /// # Returns
     ///
diff --git a/chacha20_poly1305/src/poly1305.rs b/chacha20_poly1305/src/poly1305.rs
index 9e47602e03..cf560bd0b6 100644
--- a/chacha20_poly1305/src/poly1305.rs
+++ b/chacha20_poly1305/src/poly1305.rs
@@ -27,7 +27,7 @@ pub struct Poly1305 {
 }
 
 impl Poly1305 {
-    /// Initialize authenticator with a 32-byte one-time secret key.
+    /// Initializes authenticator with a 32-byte one-time secret key.
     pub const fn new(key: [u8; 32]) -> Self {
         // Taken from Donna. Assigns r to a 26-bit 5-limb number while simultaneously 'clamping' r.
         let r0 = u32::from_le_bytes([key[0], key[1], key[2], key[3]]) & 0x3ffffff;
@@ -41,7 +41,7 @@ impl Poly1305 {
         let s2 = u32::from_le_bytes([key[24], key[25], key[26], key[27]]);
         let s3 = u32::from_le_bytes([key[28], key[29], key[30], key[31]]);
 
-        Poly1305 {
+        Self {
             r: [r0, r1, r2, r3, r4],
             s: [s0, s1, s2, s3],
             acc: [0; 5],
@@ -50,7 +50,7 @@ impl Poly1305 {
         }
     }
 
-    /// Add message to be authenticated, can be called multiple times before creating tag.
+    /// Adds message to be authenticated, can be called multiple times before creating tag.
     pub fn input(&mut self, message: &[u8]) {
         // Process previous leftovers if the message is long enough to fill the leftovers buffer. If
         // the message is too short then it will just be added to the leftovers at the end. Now if there
@@ -95,7 +95,7 @@ impl Poly1305 {
         }
     }
 
-    /// Generate authentication tag.
+    /// Generates authentication tag.
     pub fn tag(mut self) -> [u8; 16] {
         // Add any remaining leftovers to accumulator.
         if self.leftovers_len > 0 {
diff --git a/clippy.toml b/clippy.toml
index 47eac63c91..70f47d05f0 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,4 +1,4 @@
-msrv = "1.63.0"
+msrv = "1.74.0"
 too-many-arguments-threshold = 13
 avoid-breaking-exported-api = false
 doc-valid-idents = ["SegWit", "OpenSSL"]
diff --git a/consensus_encoding/CHANGELOG.md b/consensus_encoding/CHANGELOG.md
new file mode 100644
index 0000000000..1b05876b46
--- /dev/null
+++ b/consensus_encoding/CHANGELOG.md
@@ -0,0 +1,30 @@
+# 1.0.0 - 2025-10-10
+
+This changelog is a rolling description of everything that will eventually end up in `v1.0`.
+
+This was truly a team effort, notably @nyonson and @jrakibi. Also please note that many of the ideas
+and a bunch of the code, pulled out of a draft PR by @kixunil. Initial implementation was put up by
+@apoelstra, then the crew hacked on it while we all reviewed. Good effort team. Also it should be
+noted that Kix was pushing for this work for a long time and we all resisted doing it. Now he is not
+around but the work got done. Props to him for many of the ideas.
+
+- Fix `consensus-encoding` package name [#5090](https://github.com/rust-bitcoin/rust-bitcoin/pull/5090)
+- Introduce pull encoding and use it for blockhash computation [#4912](https://github.com/rust-bitcoin/rust-bitcoin/pull/4912)
+- Implement `SliceEncoder` [#4982](https://github.com/rust-bitcoin/rust-bitcoin/pull/4982)
+- Add decoder I/O drivers [#5030](https://github.com/rust-bitcoin/rust-bitcoin/pull/5030)
+- Tag composers with inline [#5037](https://github.com/rust-bitcoin/rust-bitcoin/pull/5037)
+- Clean up encoders unit tests and fix empty `SliceEncoder` [#5039](https://github.com/rust-bitcoin/rust-bitcoin/pull/5039)
+- Add encoder composition unit tests [#5045](https://github.com/rust-bitcoin/rust-bitcoin/pull/5045)
+- Implement additional decoders [#5057](https://github.com/rust-bitcoin/rust-bitcoin/pull/5057)
+- Add `CompactSizeEncoder` and refactor `WitnessEncoder` [#5086](https://github.com/rust-bitcoin/rust-bitcoin/pull/5086)
+- Add `new()` constructor to `CompactSizeDecoder` [#5089](https://github.com/rust-bitcoin/rust-bitcoin/pull/5089)
+- Remove `prefix_read` field [#5079](https://github.com/rust-bitcoin/rust-bitcoin/pull/5079)
+- Remove length prefix from the `BytesEncoder` [#5103](https://github.com/rust-bitcoin/rust-bitcoin/pull/5103)
+- Remove length prefix from `SliceEncoder` [#5108](https://github.com/rust-bitcoin/rust-bitcoin/pull/5108)
+- Rename `min_bytes_needed` to `read_limit` [#5107](https://github.com/rust-bitcoin/rust-bitcoin/pull/5107)
+- Remove transitioning state [#5130](https://github.com/rust-bitcoin/rust-bitcoin/pull/5130)
+- Composite decoder errors [#5131](https://github.com/rust-bitcoin/rust-bitcoin/pull/5131)
+
+## 0.0.0 - Placeholder release
+
+Empty crate to reserve the name on crates.io
\ No newline at end of file
diff --git a/consensus_encoding/Cargo.toml b/consensus_encoding/Cargo.toml
new file mode 100644
index 0000000000..31a5028e1a
--- /dev/null
+++ b/consensus_encoding/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "bitcoin-consensus-encoding"
+version = "1.0.0-rc.2"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>", "Nick Johnson <nick@yonson.dev>", "Tobin C. Harding <me@tobin.cc>"]
+license = "CC0-1.0"
+repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
+description = "Consensus encoding and decoding"
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["bitcoin", "no-std"]
+readme = "README.md"
+edition = "2021"
+rust-version = "1.74.0"
+exclude = ["tests", "contrib"]
+
+[features]
+default = ["std"]
+std = ["alloc", "internals/std"]
+alloc = ["internals/alloc"]
+
+[dependencies]
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.0" }
+
+[dev-dependencies]
+hex = { package = "hex-conservative", version = "0.3.0" }
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[[example]]
+name = "encoder"
+required-features = ["alloc"]
+
+[lints]
+workspace = true
diff --git a/consensus_encoding/README.md b/consensus_encoding/README.md
new file mode 100644
index 0000000000..63f6b3cdac
--- /dev/null
+++ b/consensus_encoding/README.md
@@ -0,0 +1,3 @@
+# Bitcoin Consensus Encoding
+
+This crate provides traits that can be used to encode/decode objects in a consensus-consistent way.
diff --git a/consensus_encoding/contrib/extra_lints.sh b/consensus_encoding/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/consensus_encoding/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/consensus_encoding/contrib/test_vars.sh b/consensus_encoding/contrib/test_vars.sh
new file mode 100644
index 0000000000..b7f1717315
--- /dev/null
+++ b/consensus_encoding/contrib/test_vars.sh
@@ -0,0 +1,14 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+#
+# disable verify unused vars, despite the fact that they are used when sourced
+# shellcheck disable=SC2034
+
+# Test all these features with "std" enabled.
+FEATURES_WITH_STD=""
+
+# Test all these features without "std" enabled.
+FEATURES_WITHOUT_STD="alloc"
+
+# Run these examples.
+EXAMPLES="encoder:alloc"
diff --git a/consensus_encoding/examples/encoder.rs b/consensus_encoding/examples/encoder.rs
new file mode 100644
index 0000000000..9bd8127fd2
--- /dev/null
+++ b/consensus_encoding/examples/encoder.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Example of creating an encoder that encodes a slice of encodable objects.
+
+use bitcoin_consensus_encoding as encoding;
+use encoding::{ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encodable, Encoder2, SliceEncoder};
+
+fn main() {
+    let v = vec![Inner::new(0xcafe_babe), Inner::new(0xdead_beef)];
+    let b = vec![0xab, 0xcd];
+
+    let adt = Adt::new(v, b);
+    let encoded = encoding::encode_to_vec(&adt);
+
+    let want = [0x02, 0xca, 0xfe, 0xba, 0xbe, 0xde, 0xad, 0xbe, 0xef, 0xab, 0xcd];
+    assert_eq!(encoded, want);
+}
+
+/// Some abstract data type.
+struct Adt {
+    v: Vec<Inner>,
+    b: Vec<u8>,
+}
+
+impl Adt {
+    /// Constructs a new `Adt`.
+    pub fn new(v: Vec<Inner>, b: Vec<u8>) -> Self { Self { v, b } }
+}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`Adt`] type.
+    pub struct AdtEncoder<'e>(Encoder2<Encoder2<CompactSizeEncoder, SliceEncoder<'e, Inner>>, BytesEncoder<'e>>);
+}
+
+impl Encodable for Adt {
+    type Encoder<'a>
+        = AdtEncoder<'a>
+    where
+        Self: 'a;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let a = Encoder2::new(
+            CompactSizeEncoder::new(self.v.len()),
+            SliceEncoder::without_length_prefix(&self.v),
+        );
+        let b = BytesEncoder::without_length_prefix(self.b.as_ref());
+
+        AdtEncoder(Encoder2::new(a, b))
+    }
+}
+
+/// A simple data type to use as list item.
+#[derive(Debug, Default, Clone)]
+pub struct Inner(u32);
+
+impl Inner {
+    /// Constructs a new `Inner`.
+    pub fn new(x: u32) -> Self { Self(x) }
+
+    /// Returns some meaningful 4 byte array for this type.
+    pub fn to_array(&self) -> [u8; 4] { self.0.to_be_bytes() }
+}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`Inner`] type.
+    pub struct InnerEncoder(ArrayEncoder<4>);
+}
+
+impl Encodable for Inner {
+    type Encoder<'e> = InnerEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        InnerEncoder(ArrayEncoder::without_length_prefix(self.to_array()))
+    }
+}
diff --git a/consensus_encoding/src/decode/decoders.rs b/consensus_encoding/src/decode/decoders.rs
new file mode 100644
index 0000000000..1ddafa40b1
--- /dev/null
+++ b/consensus_encoding/src/decode/decoders.rs
@@ -0,0 +1,1465 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Primitive decoders.
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+#[cfg(feature = "alloc")]
+use core::convert::Infallible;
+use core::{fmt, mem};
+
+use internals::write_err;
+
+#[cfg(feature = "alloc")]
+use super::Decodable;
+use super::Decoder;
+
+/// Maximum size, in bytes, of a vector we are allowed to decode.
+///
+/// This is also the default value limit that can be decoded with a decoder from
+/// [`CompactSizeDecoder::new`].
+const MAX_VEC_SIZE: usize = 4_000_000;
+
+/// Maximum amount of memory (in bytes) to allocate at once when deserializing vectors.
+#[cfg(feature = "alloc")]
+const MAX_VECTOR_ALLOCATE: usize = 1_000_000;
+
+/// A decoder that decodes a byte vector.
+///
+/// The encoding is expected to start with the number of encoded bytes (length prefix).
+#[cfg(feature = "alloc")]
+pub struct ByteVecDecoder {
+    prefix_decoder: Option<CompactSizeDecoder>,
+    buffer: Vec<u8>,
+    bytes_expected: usize,
+    bytes_written: usize,
+}
+
+#[cfg(feature = "alloc")]
+impl ByteVecDecoder {
+    /// Constructs a new byte decoder.
+    pub const fn new() -> Self {
+        Self {
+            prefix_decoder: Some(CompactSizeDecoder::new()),
+            buffer: Vec::new(),
+            bytes_expected: 0,
+            bytes_written: 0,
+        }
+    }
+
+    /// Reserves capacity for byte vectors in batches.
+    ///
+    /// Reserves up to `MAX_VECTOR_ALLOCATE` bytes when the buffer has no remaining capacity.
+    ///
+    /// Documentation adapted from Bitcoin Core:
+    ///
+    /// > For `DoS` prevention, do not blindly allocate as much as the stream claims to contain.
+    /// > Instead, allocate in ~1 MB batches, so that an attacker actually needs to provide X MB of
+    /// > data to make us allocate X+1 MB of memory.
+    ///
+    /// ref: <https://github.com/bitcoin/bitcoin/blob/72511fd02e72b74be11273e97bd7911786a82e54/src/serialize.h#L669C2-L672C1>
+    fn reserve(&mut self) {
+        if self.buffer.len() == self.buffer.capacity() {
+            let bytes_remaining = self.bytes_expected - self.bytes_written;
+            let batch_size = bytes_remaining.min(MAX_VECTOR_ALLOCATE);
+            self.buffer.reserve_exact(batch_size);
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Default for ByteVecDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "alloc")]
+impl Decoder for ByteVecDecoder {
+    type Output = Vec<u8>;
+    type Error = ByteVecDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        use {ByteVecDecoderError as E, ByteVecDecoderErrorInner as Inner};
+
+        if let Some(mut decoder) = self.prefix_decoder.take() {
+            if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))? {
+                self.prefix_decoder = Some(decoder);
+                return Ok(true);
+            }
+            self.bytes_expected = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+            self.prefix_decoder = None;
+
+            // For DoS prevention, let's not allocate all memory upfront.
+        }
+
+        self.reserve();
+
+        let remaining = self.bytes_expected - self.bytes_written;
+        let available_capacity = self.buffer.capacity() - self.buffer.len();
+        let copy_len = bytes.len().min(remaining).min(available_capacity);
+
+        self.buffer.extend_from_slice(&bytes[..copy_len]);
+        self.bytes_written += copy_len;
+        *bytes = &bytes[copy_len..];
+
+        // Return true if we still need more data.
+        Ok(self.bytes_written < self.bytes_expected)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use {ByteVecDecoderError as E, ByteVecDecoderErrorInner as Inner};
+
+        if self.bytes_written == self.bytes_expected {
+            Ok(self.buffer)
+        } else {
+            Err(E(Inner::UnexpectedEof(UnexpectedEofError {
+                missing: self.bytes_expected - self.bytes_written,
+            })))
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        if let Some(prefix_decoder) = &self.prefix_decoder {
+            prefix_decoder.read_limit()
+        } else {
+            self.bytes_expected - self.bytes_written
+        }
+    }
+}
+
+/// A decoder that decodes a vector of `T`s.
+///
+/// The decoding is expected to start with expected number of items in the vector.
+#[cfg(feature = "alloc")]
+pub struct VecDecoder<T: Decodable> {
+    prefix_decoder: Option<CompactSizeDecoder>,
+    length: usize,
+    buffer: Vec<T>,
+    decoder: Option<<T as Decodable>::Decoder>,
+}
+
+#[cfg(feature = "alloc")]
+impl<T: Decodable> VecDecoder<T> {
+    /// Constructs a new byte decoder.
+    pub const fn new() -> Self {
+        Self {
+            prefix_decoder: Some(CompactSizeDecoder::new()),
+            length: 0,
+            buffer: Vec::new(),
+            decoder: None,
+        }
+    }
+
+    /// Reserves capacity for typed vectors in batches.
+    ///
+    /// Calculates how many elements of type `T` fit within `MAX_VECTOR_ALLOCATE` bytes and reserves
+    /// up to that amount when the buffer reaches capacity.
+    ///
+    /// Documentation adapted from Bitcoin Core:
+    ///
+    /// > For `DoS` prevention, do not blindly allocate as much as the stream claims to contain.
+    /// > Instead, allocate in ~1 MB batches, so that an attacker actually needs to provide X MB of
+    /// > data to make us allocate X+1 MB of memory.
+    ///
+    /// ref: <https://github.com/bitcoin/bitcoin/blob/72511fd02e72b74be11273e97bd7911786a82e54/src/serialize.h#L669C2-L672C1>
+    fn reserve(&mut self) {
+        if self.buffer.len() == self.buffer.capacity() {
+            let elements_remaining = self.length - self.buffer.len();
+            let element_size = mem::size_of::<T>().max(1);
+            let batch_elements = MAX_VECTOR_ALLOCATE / element_size;
+            let elements_to_reserve = elements_remaining.min(batch_elements);
+            self.buffer.reserve_exact(elements_to_reserve);
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<T: Decodable> Default for VecDecoder<T> {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "alloc")]
+impl<T: Decodable> Decoder for VecDecoder<T> {
+    type Output = Vec<T>;
+    type Error = VecDecoderError<<<T as Decodable>::Decoder as Decoder>::Error>;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        use {VecDecoderError as E, VecDecoderErrorInner as Inner};
+
+        if let Some(mut decoder) = self.prefix_decoder.take() {
+            if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))? {
+                self.prefix_decoder = Some(decoder);
+                return Ok(true);
+            }
+            self.length = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+            if self.length == 0 {
+                return Ok(false);
+            }
+
+            self.prefix_decoder = None;
+
+            // For DoS prevention, let's not allocate all memory upfront.
+        }
+
+        while !bytes.is_empty() {
+            self.reserve();
+
+            let mut decoder = self.decoder.take().unwrap_or_else(T::decoder);
+
+            if decoder.push_bytes(bytes).map_err(|e| E(Inner::Item(e)))? {
+                self.decoder = Some(decoder);
+                return Ok(true);
+            }
+            let item = decoder.end().map_err(|e| E(Inner::Item(e)))?;
+            self.buffer.push(item);
+
+            if self.buffer.len() == self.length {
+                return Ok(false);
+            }
+        }
+
+        if self.buffer.len() == self.length {
+            Ok(false)
+        } else {
+            Ok(true)
+        }
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use VecDecoderErrorInner as E;
+
+        if self.buffer.len() == self.length {
+            Ok(self.buffer)
+        } else {
+            Err(VecDecoderError(E::UnexpectedEof(UnexpectedEofError {
+                missing: self.length - self.buffer.len(),
+            })))
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        if let Some(prefix_decoder) = &self.prefix_decoder {
+            prefix_decoder.read_limit()
+        } else if let Some(decoder) = &self.decoder {
+            decoder.read_limit()
+        } else if self.buffer.len() == self.length {
+            // Totally done.
+            0
+        } else {
+            let items_left_to_decode = self.length - self.buffer.len();
+            let decoder = T::decoder();
+            // This could be inaccurate (eg 1 for a `ByteVecDecoder`) but its the best we can do.
+            let limit_per_decoder = decoder.read_limit();
+            items_left_to_decode * limit_per_decoder
+        }
+    }
+}
+
+/// A decoder that expects exactly N bytes and returns them as an array.
+pub struct ArrayDecoder<const N: usize> {
+    buffer: [u8; N],
+    bytes_written: usize,
+}
+
+impl<const N: usize> ArrayDecoder<N> {
+    /// Constructs a new array decoder that expects exactly N bytes.
+    pub const fn new() -> Self { Self { buffer: [0; N], bytes_written: 0 } }
+}
+
+impl<const N: usize> Default for ArrayDecoder<N> {
+    fn default() -> Self { Self::new() }
+}
+
+impl<const N: usize> Decoder for ArrayDecoder<N> {
+    type Output = [u8; N];
+    type Error = UnexpectedEofError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        let remaining_space = N - self.bytes_written;
+        let copy_len = bytes.len().min(remaining_space);
+
+        if copy_len > 0 {
+            self.buffer[self.bytes_written..self.bytes_written + copy_len]
+                .copy_from_slice(&bytes[..copy_len]);
+            self.bytes_written += copy_len;
+            // Advance the slice reference to consume the bytes.
+            *bytes = &bytes[copy_len..];
+        }
+
+        // Return true if we still need more data.
+        Ok(self.bytes_written < N)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        if self.bytes_written == N {
+            Ok(self.buffer)
+        } else {
+            Err(UnexpectedEofError { missing: N - self.bytes_written })
+        }
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { N - self.bytes_written }
+}
+
+/// A decoder which wraps two inner decoders and returns the output of both.
+pub struct Decoder2<A, B>
+where
+    A: Decoder,
+    B: Decoder,
+{
+    state: Decoder2State<A, B>,
+}
+
+enum Decoder2State<A: Decoder, B: Decoder> {
+    /// Decoding the first decoder, with second decoder waiting.
+    First(A, B),
+    /// Decoding the second decoder, with the first result stored.
+    Second(A::Output, B),
+    /// Decoder has failed and cannot be used again.
+    Errored,
+}
+
+impl<A, B> Decoder2<A, B>
+where
+    A: Decoder,
+    B: Decoder,
+{
+    /// Constructs a new composite decoder.
+    pub const fn new(first: A, second: B) -> Self {
+        Self { state: Decoder2State::First(first, second) }
+    }
+}
+
+impl<A, B> Decoder for Decoder2<A, B>
+where
+    A: Decoder,
+    B: Decoder,
+{
+    type Output = (A::Output, B::Output);
+    type Error = Decoder2Error<A::Error, B::Error>;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        loop {
+            match &mut self.state {
+                Decoder2State::First(first_decoder, _) => {
+                    if first_decoder.push_bytes(bytes).map_err(Decoder2Error::First)? {
+                        // First decoder wants more data.
+                        return Ok(true);
+                    }
+
+                    // First decoder is complete, transition to second.
+                    // If the first decoder fails, the composite decoder
+                    // remains in an Errored state.
+                    match mem::replace(&mut self.state, Decoder2State::Errored) {
+                        Decoder2State::First(first, second) => {
+                            let first_result = first.end().map_err(Decoder2Error::First)?;
+                            self.state = Decoder2State::Second(first_result, second);
+                        }
+                        _ => unreachable!("we know we're in First state"),
+                    }
+                }
+                Decoder2State::Second(_, second_decoder) => {
+                    return second_decoder.push_bytes(bytes).map_err(|error| {
+                        self.state = Decoder2State::Errored;
+                        Decoder2Error::Second(error)
+                    });
+                }
+                Decoder2State::Errored => {
+                    panic!("use of failed decoder");
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        match self.state {
+            Decoder2State::First(first_decoder, second_decoder) => {
+                // This branch is most likely an error since the decoder
+                // never got to the second one. But letting the error bubble
+                // up naturally from the child decoders.
+                let first_result = first_decoder.end().map_err(Decoder2Error::First)?;
+                let second_result = second_decoder.end().map_err(Decoder2Error::Second)?;
+                Ok((first_result, second_result))
+            }
+            Decoder2State::Second(first_result, second_decoder) => {
+                let second_result = second_decoder.end().map_err(Decoder2Error::Second)?;
+                Ok((first_result, second_result))
+            }
+            Decoder2State::Errored => {
+                panic!("use of failed decoder");
+            }
+        }
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize {
+        match &self.state {
+            Decoder2State::First(first_decoder, second_decoder) =>
+                first_decoder.read_limit() + second_decoder.read_limit(),
+            Decoder2State::Second(_, second_decoder) => second_decoder.read_limit(),
+            Decoder2State::Errored => 0,
+        }
+    }
+}
+
+/// A decoder which decodes three objects, one after the other.
+pub struct Decoder3<A, B, C>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+{
+    inner: Decoder2<Decoder2<A, B>, C>,
+}
+
+impl<A, B, C> Decoder3<A, B, C>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+{
+    /// Constructs a new composite decoder.
+    pub const fn new(dec_1: A, dec_2: B, dec_3: C) -> Self {
+        Self { inner: Decoder2::new(Decoder2::new(dec_1, dec_2), dec_3) }
+    }
+}
+
+impl<A, B, C> Decoder for Decoder3<A, B, C>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+{
+    type Output = (A::Output, B::Output, C::Output);
+    type Error = Decoder3Error<A::Error, B::Error, C::Error>;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(|error| match error {
+            Decoder2Error::First(Decoder2Error::First(a)) => Decoder3Error::First(a),
+            Decoder2Error::First(Decoder2Error::Second(b)) => Decoder3Error::Second(b),
+            Decoder2Error::Second(c) => Decoder3Error::Third(c),
+        })
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let result = self.inner.end().map_err(|error| match error {
+            Decoder2Error::First(Decoder2Error::First(a)) => Decoder3Error::First(a),
+            Decoder2Error::First(Decoder2Error::Second(b)) => Decoder3Error::Second(b),
+            Decoder2Error::Second(c) => Decoder3Error::Third(c),
+        })?;
+
+        let ((first, second), third) = result;
+        Ok((first, second, third))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// A decoder which decodes four objects, one after the other.
+pub struct Decoder4<A, B, C, D>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+{
+    inner: Decoder2<Decoder2<A, B>, Decoder2<C, D>>,
+}
+
+impl<A, B, C, D> Decoder4<A, B, C, D>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+{
+    /// Constructs a new composite decoder.
+    pub const fn new(dec_1: A, dec_2: B, dec_3: C, dec_4: D) -> Self {
+        Self { inner: Decoder2::new(Decoder2::new(dec_1, dec_2), Decoder2::new(dec_3, dec_4)) }
+    }
+}
+
+impl<A, B, C, D> Decoder for Decoder4<A, B, C, D>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+{
+    type Output = (A::Output, B::Output, C::Output, D::Output);
+    type Error = Decoder4Error<A::Error, B::Error, C::Error, D::Error>;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(|error| match error {
+            Decoder2Error::First(Decoder2Error::First(a)) => Decoder4Error::First(a),
+            Decoder2Error::First(Decoder2Error::Second(b)) => Decoder4Error::Second(b),
+            Decoder2Error::Second(Decoder2Error::First(c)) => Decoder4Error::Third(c),
+            Decoder2Error::Second(Decoder2Error::Second(d)) => Decoder4Error::Fourth(d),
+        })
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let result = self.inner.end().map_err(|error| match error {
+            Decoder2Error::First(Decoder2Error::First(a)) => Decoder4Error::First(a),
+            Decoder2Error::First(Decoder2Error::Second(b)) => Decoder4Error::Second(b),
+            Decoder2Error::Second(Decoder2Error::First(c)) => Decoder4Error::Third(c),
+            Decoder2Error::Second(Decoder2Error::Second(d)) => Decoder4Error::Fourth(d),
+        })?;
+
+        let ((first, second), (third, fourth)) = result;
+        Ok((first, second, third, fourth))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// A decoder which decodes six objects, one after the other.
+#[allow(clippy::type_complexity)] // Nested composition is easier than flattened alternatives.
+pub struct Decoder6<A, B, C, D, E, F>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+    E: Decoder,
+    F: Decoder,
+{
+    inner: Decoder2<Decoder3<A, B, C>, Decoder3<D, E, F>>,
+}
+
+impl<A, B, C, D, E, F> Decoder6<A, B, C, D, E, F>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+    E: Decoder,
+    F: Decoder,
+{
+    /// Constructs a new composite decoder.
+    pub const fn new(dec_1: A, dec_2: B, dec_3: C, dec_4: D, dec_5: E, dec_6: F) -> Self {
+        Self {
+            inner: Decoder2::new(
+                Decoder3::new(dec_1, dec_2, dec_3),
+                Decoder3::new(dec_4, dec_5, dec_6),
+            ),
+        }
+    }
+}
+
+impl<A, B, C, D, E, F> Decoder for Decoder6<A, B, C, D, E, F>
+where
+    A: Decoder,
+    B: Decoder,
+    C: Decoder,
+    D: Decoder,
+    E: Decoder,
+    F: Decoder,
+{
+    type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output);
+    type Error = Decoder6Error<A::Error, B::Error, C::Error, D::Error, E::Error, F::Error>;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(|error| match error {
+            Decoder2Error::First(Decoder3Error::First(a)) => Decoder6Error::First(a),
+            Decoder2Error::First(Decoder3Error::Second(b)) => Decoder6Error::Second(b),
+            Decoder2Error::First(Decoder3Error::Third(c)) => Decoder6Error::Third(c),
+            Decoder2Error::Second(Decoder3Error::First(d)) => Decoder6Error::Fourth(d),
+            Decoder2Error::Second(Decoder3Error::Second(e)) => Decoder6Error::Fifth(e),
+            Decoder2Error::Second(Decoder3Error::Third(f)) => Decoder6Error::Sixth(f),
+        })
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let result = self.inner.end().map_err(|error| match error {
+            Decoder2Error::First(Decoder3Error::First(a)) => Decoder6Error::First(a),
+            Decoder2Error::First(Decoder3Error::Second(b)) => Decoder6Error::Second(b),
+            Decoder2Error::First(Decoder3Error::Third(c)) => Decoder6Error::Third(c),
+            Decoder2Error::Second(Decoder3Error::First(d)) => Decoder6Error::Fourth(d),
+            Decoder2Error::Second(Decoder3Error::Second(e)) => Decoder6Error::Fifth(e),
+            Decoder2Error::Second(Decoder3Error::Third(f)) => Decoder6Error::Sixth(f),
+        })?;
+
+        let ((first, second, third), (fourth, fifth, sixth)) = result;
+        Ok((first, second, third, fourth, fifth, sixth))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// Decodes a compact size encoded integer.
+///
+/// For more information about decoder see the documentation of the [`Decoder`] trait.
+#[derive(Debug, Clone)]
+pub struct CompactSizeDecoder {
+    buf: internals::array_vec::ArrayVec<u8, 9>,
+    limit: usize,
+}
+
+impl CompactSizeDecoder {
+    /// Constructs a new compact size decoder.
+    ///
+    /// Consensus encoded vectors can be up to 4,000,000 bytes long.
+    /// This is a theoretical max since block size is 4 meg wu and minimum vector element is one byte.
+    ///
+    /// The final call to [`CompactSizeDecoder::end`] on this decoder will fail if the
+    /// decoded value exceeds 4,000,000 or won't fit in a `usize`.
+    pub const fn new() -> Self {
+        Self { buf: internals::array_vec::ArrayVec::new(), limit: MAX_VEC_SIZE }
+    }
+
+    /// Constructs a new compact size decoder with encoded value limited to the provided usize.
+    ///
+    /// The final call to [`CompactSizeDecoder::end`] on this decoder will fail if the
+    /// decoded value exceeds `limit` or won't fit in a `usize`.
+    pub const fn new_with_limit(limit: usize) -> Self {
+        Self { buf: internals::array_vec::ArrayVec::new(), limit }
+    }
+}
+
+impl Default for CompactSizeDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl Decoder for CompactSizeDecoder {
+    type Output = usize;
+    type Error = CompactSizeDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        if bytes.is_empty() {
+            return Ok(true);
+        }
+
+        if self.buf.is_empty() {
+            self.buf.push(bytes[0]);
+            *bytes = &bytes[1..];
+        }
+        let len = match self.buf[0] {
+            0xFF => 9,
+            0xFE => 5,
+            0xFD => 3,
+            _ => 1,
+        };
+        let to_copy = bytes.len().min(len - self.buf.len());
+        self.buf.extend_from_slice(&bytes[..to_copy]);
+        *bytes = &bytes[to_copy..];
+
+        Ok(self.buf.len() != len)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use CompactSizeDecoderErrorInner as E;
+
+        fn arr<const N: usize>(slice: &[u8]) -> Result<[u8; N], CompactSizeDecoderError> {
+            slice.try_into().map_err(|_| {
+                CompactSizeDecoderError(E::UnexpectedEof { required: N, received: slice.len() })
+            })
+        }
+
+        let (first, payload) = self
+            .buf
+            .split_first()
+            .ok_or(CompactSizeDecoderError(E::UnexpectedEof { required: 1, received: 0 }))?;
+
+        let dec_value = match *first {
+            0xFF => {
+                let x = u64::from_le_bytes(arr(payload)?);
+                if x < 0x100_000_000 {
+                    Err(CompactSizeDecoderError(E::NonMinimal { value: x }))
+                } else {
+                    Ok(x)
+                }
+            }
+            0xFE => {
+                let x = u32::from_le_bytes(arr(payload)?);
+                if x < 0x10000 {
+                    Err(CompactSizeDecoderError(E::NonMinimal { value: x.into() }))
+                } else {
+                    Ok(x.into())
+                }
+            }
+            0xFD => {
+                let x = u16::from_le_bytes(arr(payload)?);
+                if x < 0xFD {
+                    Err(CompactSizeDecoderError(E::NonMinimal { value: x.into() }))
+                } else {
+                    Ok(x.into())
+                }
+            }
+            n => Ok(n.into()),
+        }?;
+
+        // This error is returned if dec_value is outside of the usize range, or
+        // if it is above the given limit.
+        let make_err = || {
+            CompactSizeDecoderError(E::ValueExceedsLimit(LengthPrefixExceedsMaxError {
+                value: dec_value,
+                limit: self.limit,
+            }))
+        };
+
+        usize::try_from(dec_value).map_err(|_| make_err()).and_then(|nsize| {
+            if nsize > self.limit {
+                Err(make_err())
+            } else {
+                Ok(nsize)
+            }
+        })
+    }
+
+    fn read_limit(&self) -> usize {
+        match self.buf.len() {
+            0 => 1,
+            already_read => match self.buf[0] {
+                0xFF => 9_usize.saturating_sub(already_read),
+                0xFE => 5_usize.saturating_sub(already_read),
+                0xFD => 3_usize.saturating_sub(already_read),
+                _ => 0,
+            },
+        }
+    }
+}
+
+/// An error consensus decoding a compact size encoded integer.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CompactSizeDecoderError(CompactSizeDecoderErrorInner);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum CompactSizeDecoderErrorInner {
+    /// Returned when the decoder reaches end of stream (EOF).
+    UnexpectedEof {
+        /// How many bytes were required.
+        required: usize,
+        /// How many bytes were received.
+        received: usize,
+    },
+    /// Returned when the encoding is not minimal
+    NonMinimal {
+        /// The encoded value.
+        value: u64,
+    },
+    /// Returned when the encoded value exceeds the decoder's limit.
+    ValueExceedsLimit(LengthPrefixExceedsMaxError),
+}
+
+impl fmt::Display for CompactSizeDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use CompactSizeDecoderErrorInner as E;
+
+        match self.0 {
+            E::UnexpectedEof { required: 1, received: 0 } => {
+                write!(f, "required at least one byte but the input is empty")
+            }
+            E::UnexpectedEof { required, received: 0 } => {
+                write!(f, "required at least {} bytes but the input is empty", required)
+            }
+            E::UnexpectedEof { required, received } => write!(
+                f,
+                "required at least {} bytes but only {} bytes were received",
+                required, received
+            ),
+            E::NonMinimal { value } => write!(f, "the value {} was not encoded minimally", value),
+            E::ValueExceedsLimit(ref e) => write_err!(f, "value exceeds limit"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CompactSizeDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use CompactSizeDecoderErrorInner as E;
+
+        match self {
+            Self(E::ValueExceedsLimit(ref e)) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+/// The error returned by the [`ByteVecDecoder`].
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ByteVecDecoderError(ByteVecDecoderErrorInner);
+
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum ByteVecDecoderErrorInner {
+    /// Error decoding the byte vector length prefix.
+    LengthPrefixDecode(CompactSizeDecoderError),
+    /// Not enough bytes given to decoder.
+    UnexpectedEof(UnexpectedEofError),
+}
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for ByteVecDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for ByteVecDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ByteVecDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => write_err!(f, "byte vec decoder error"; e),
+            E::UnexpectedEof(ref e) => write_err!(f, "byte vec decoder error"; e),
+        }
+    }
+}
+
+#[cfg(all(feature = "std", feature = "alloc"))]
+impl std::error::Error for ByteVecDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ByteVecDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => Some(e),
+            E::UnexpectedEof(ref e) => Some(e),
+        }
+    }
+}
+
+/// The error returned by the [`VecDecoder`].
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VecDecoderError<Err>(VecDecoderErrorInner<Err>);
+
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum VecDecoderErrorInner<Err> {
+    /// Error decoding the vector length prefix.
+    LengthPrefixDecode(CompactSizeDecoderError),
+    /// Error while decoding an item.
+    Item(Err),
+    /// Not enough bytes given to decoder.
+    UnexpectedEof(UnexpectedEofError),
+}
+
+#[cfg(feature = "alloc")]
+impl<Err> From<Infallible> for VecDecoderError<Err> {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl<Err> fmt::Display for VecDecoderError<Err>
+where
+    Err: fmt::Display + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use VecDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => write_err!(f, "vec decoder error"; e),
+            E::Item(ref e) => write_err!(f, "vec decoder error"; e),
+            E::UnexpectedEof(ref e) => write_err!(f, "vec decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<Err> std::error::Error for VecDecoderError<Err>
+where
+    Err: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use VecDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => Some(e),
+            E::Item(ref e) => Some(e),
+            E::UnexpectedEof(ref e) => Some(e),
+        }
+    }
+}
+
+/// Length prefix exceeds the configured limit.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LengthPrefixExceedsMaxError {
+    /// Decoded value of the compact encoded length prefix.
+    value: u64,
+    /// The value limit that the length prefix exceeds.
+    limit: usize,
+}
+
+impl core::fmt::Display for LengthPrefixExceedsMaxError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "length prefix {} exceeds max value {}", self.value, self.limit)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for LengthPrefixExceedsMaxError {}
+
+/// Not enough bytes given to decoder.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UnexpectedEofError {
+    /// Number of bytes missing to complete decoder.
+    missing: usize,
+}
+
+impl fmt::Display for UnexpectedEofError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "not enough bytes for decoder, {} more bytes required", self.missing)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnexpectedEofError {}
+
+/// Error type for [`Decoder2`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Decoder2Error<A, B> {
+    /// Error from the first decoder.
+    First(A),
+    /// Error from the second decoder.
+    Second(B),
+}
+
+impl<A, B> fmt::Display for Decoder2Error<A, B>
+where
+    A: fmt::Display,
+    B: fmt::Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::First(ref e) => write_err!(f, "first decoder error"; e),
+            Self::Second(ref e) => write_err!(f, "second decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<A, B> std::error::Error for Decoder2Error<A, B>
+where
+    A: std::error::Error + 'static,
+    B: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::First(ref e) => Some(e),
+            Self::Second(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error type for [`Decoder3`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Decoder3Error<A, B, C> {
+    /// Error from the first decoder.
+    First(A),
+    /// Error from the second decoder.
+    Second(B),
+    /// Error from the third decoder.
+    Third(C),
+}
+
+impl<A, B, C> fmt::Display for Decoder3Error<A, B, C>
+where
+    A: fmt::Display,
+    B: fmt::Display,
+    C: fmt::Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::First(ref e) => write_err!(f, "first decoder error"; e),
+            Self::Second(ref e) => write_err!(f, "second decoder error"; e),
+            Self::Third(ref e) => write_err!(f, "third decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<A, B, C> std::error::Error for Decoder3Error<A, B, C>
+where
+    A: std::error::Error + 'static,
+    B: std::error::Error + 'static,
+    C: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::First(ref e) => Some(e),
+            Self::Second(ref e) => Some(e),
+            Self::Third(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error type for [`Decoder4`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Decoder4Error<A, B, C, D> {
+    /// Error from the first decoder.
+    First(A),
+    /// Error from the second decoder.
+    Second(B),
+    /// Error from the third decoder.
+    Third(C),
+    /// Error from the fourth decoder.
+    Fourth(D),
+}
+
+impl<A, B, C, D> fmt::Display for Decoder4Error<A, B, C, D>
+where
+    A: fmt::Display,
+    B: fmt::Display,
+    C: fmt::Display,
+    D: fmt::Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::First(ref e) => write_err!(f, "first decoder error"; e),
+            Self::Second(ref e) => write_err!(f, "second decoder error"; e),
+            Self::Third(ref e) => write_err!(f, "third decoder error"; e),
+            Self::Fourth(ref e) => write_err!(f, "fourth decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<A, B, C, D> std::error::Error for Decoder4Error<A, B, C, D>
+where
+    A: std::error::Error + 'static,
+    B: std::error::Error + 'static,
+    C: std::error::Error + 'static,
+    D: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::First(ref e) => Some(e),
+            Self::Second(ref e) => Some(e),
+            Self::Third(ref e) => Some(e),
+            Self::Fourth(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error type for [`Decoder6`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Decoder6Error<A, B, C, D, E, F> {
+    /// Error from the first decoder.
+    First(A),
+    /// Error from the second decoder.
+    Second(B),
+    /// Error from the third decoder.
+    Third(C),
+    /// Error from the fourth decoder.
+    Fourth(D),
+    /// Error from the fifth decoder.
+    Fifth(E),
+    /// Error from the sixth decoder.
+    Sixth(F),
+}
+
+impl<A, B, C, D, E, F> fmt::Display for Decoder6Error<A, B, C, D, E, F>
+where
+    A: fmt::Display,
+    B: fmt::Display,
+    C: fmt::Display,
+    D: fmt::Display,
+    E: fmt::Display,
+    F: fmt::Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::First(ref e) => write_err!(f, "first decoder error"; e),
+            Self::Second(ref e) => write_err!(f, "second decoder error"; e),
+            Self::Third(ref e) => write_err!(f, "third decoder error"; e),
+            Self::Fourth(ref e) => write_err!(f, "fourth decoder error"; e),
+            Self::Fifth(ref e) => write_err!(f, "fifth decoder error"; e),
+            Self::Sixth(ref e) => write_err!(f, "sixth decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<A, B, C, D, E, F> std::error::Error for Decoder6Error<A, B, C, D, E, F>
+where
+    A: std::error::Error + 'static,
+    B: std::error::Error + 'static,
+    C: std::error::Error + 'static,
+    D: std::error::Error + 'static,
+    E: std::error::Error + 'static,
+    F: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::First(ref e) => Some(e),
+            Self::Second(ref e) => Some(e),
+            Self::Third(ref e) => Some(e),
+            Self::Fourth(ref e) => Some(e),
+            Self::Fifth(ref e) => Some(e),
+            Self::Sixth(ref e) => Some(e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::vec;
+    #[cfg(feature = "alloc")]
+    use alloc::vec::Vec;
+    #[cfg(feature = "alloc")]
+    use core::iter;
+    #[cfg(feature = "std")]
+    use std::io::Cursor;
+
+    use super::*;
+
+    // Stress test the push_bytes impl by passing in a single byte slice repeatedly.
+    macro_rules! check_decode_one_byte_at_a_time {
+        ($decoder:expr; $($test_name:ident, $want:expr, $array:expr);* $(;)?) => {
+            $(
+                #[test]
+                #[allow(non_snake_case)]
+                fn $test_name() {
+                    let mut decoder = $decoder;
+
+                    for (i, _) in $array.iter().enumerate() {
+                        if i < $array.len() - 1 {
+                            let mut p = &$array[i..i+1];
+                            assert!(decoder.push_bytes(&mut p).unwrap());
+                        } else {
+                            // last byte: `push_bytes` should return false since no more bytes required.
+                            let mut p = &$array[i..];
+                            assert!(!decoder.push_bytes(&mut p).unwrap());
+                        }
+                    }
+
+                    let got = decoder.end().unwrap();
+                    assert_eq!(got, $want);
+                }
+            )*
+
+        }
+    }
+
+    check_decode_one_byte_at_a_time! {
+        CompactSizeDecoder::new_with_limit(0xF0F0_F0F0);
+        decode_compact_size_0x10, 0x10, [0x10];
+        decode_compact_size_0xFC, 0xFC, [0xFC];
+        decode_compact_size_0xFD, 0xFD, [0xFD, 0xFD, 0x00];
+        decode_compact_size_0x100, 0x100, [0xFD, 0x00, 0x01];
+        decode_compact_size_0xFFF, 0x0FFF, [0xFD, 0xFF, 0x0F];
+        decode_compact_size_0x0F0F_0F0F, 0x0F0F_0F0F, [0xFE, 0xF, 0xF, 0xF, 0xF];
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    #[allow(non_snake_case)]
+    fn decode_compact_size_0xF0F0_F0F0_F0E0() {
+        let mut decoder = CompactSizeDecoder::new_with_limit(0xF0F0_F0F0_F0EF);
+        let array = [0xFF, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0];
+
+        for (i, _) in array.iter().enumerate() {
+            if i < array.len() - 1 {
+                let mut p = &array[i..=i];
+                assert!(decoder.push_bytes(&mut p).unwrap());
+            } else {
+                // last byte: `push_bytes` should return false since no more bytes required.
+                let mut p = &array[i..];
+                assert!(!decoder.push_bytes(&mut p).unwrap());
+            }
+        }
+
+        let got = decoder.end().unwrap();
+        assert_eq!(got, 0xF0F0_F0F0_F0E0);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn compact_size_zero() {
+        // Zero (eg for an empty vector) with a couple of arbitrary extra bytes.
+        let encoded = alloc::vec![0x00, 0xFF, 0xFF];
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = CompactSizeDecoder::new();
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+
+        let got = decoder.end().unwrap();
+        assert_eq!(got, 0);
+    }
+
+    #[cfg(feature = "alloc")]
+    fn two_fifty_six_bytes_encoded() -> Vec<u8> {
+        let data = [0xff; 256];
+        let mut v = Vec::with_capacity(259);
+
+        v.extend_from_slice(&[0xFD, 0x00, 0x01]); // 256 encoded as a  compact size.
+        v.extend_from_slice(&data);
+        v
+    }
+
+    #[cfg(feature = "alloc")]
+    check_decode_one_byte_at_a_time! {
+        ByteVecDecoder::default();
+            decode_byte_vec, alloc::vec![0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef],
+        [0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
+            decode_byte_vec_multi_byte_length_prefix, [0xff; 256], two_fifty_six_bytes_encoded();
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn byte_vec_decoder_reserves_in_batches() {
+        // A small number of extra bytes so we extend exactly by the remainder
+        // instead of another full batch.
+        let tail_length: usize = 11;
+
+        let total_len = MAX_VECTOR_ALLOCATE + tail_length;
+        let total_len_le = u32::try_from(total_len).expect("total_len fits u32").to_le_bytes();
+        let mut decoder = ByteVecDecoder::new();
+
+        let mut prefix = vec![0xFE]; // total_len_le is a compact size of four bytes.
+        prefix.extend_from_slice(&total_len_le);
+        prefix.push(0xAA);
+        let mut prefix_slice = prefix.as_slice();
+        decoder.push_bytes(&mut prefix_slice).expect("length plus first element");
+        assert!(prefix_slice.is_empty());
+
+        assert_eq!(decoder.buffer.capacity(), MAX_VECTOR_ALLOCATE);
+        assert_eq!(decoder.buffer.len(), 1);
+        assert_eq!(decoder.buffer[0], 0xAA);
+
+        let fill = vec![0xBB; MAX_VECTOR_ALLOCATE - 1];
+        let mut fill_slice = fill.as_slice();
+        decoder.push_bytes(&mut fill_slice).expect("fills to batch boundary, full capacity");
+        assert!(fill_slice.is_empty());
+
+        assert_eq!(decoder.buffer.capacity(), MAX_VECTOR_ALLOCATE);
+        assert_eq!(decoder.buffer.len(), MAX_VECTOR_ALLOCATE);
+        assert_eq!(decoder.buffer[MAX_VECTOR_ALLOCATE - 1], 0xBB);
+
+        let mut tail = vec![0xCC];
+        tail.extend([0xDD].repeat(tail_length - 1));
+        let mut tail_slice = tail.as_slice();
+        decoder.push_bytes(&mut tail_slice).expect("fills the remaining bytes");
+        assert!(tail_slice.is_empty());
+
+        assert_eq!(decoder.buffer.capacity(), MAX_VECTOR_ALLOCATE + tail_length);
+        assert_eq!(decoder.buffer.len(), total_len);
+        assert_eq!(decoder.buffer[MAX_VECTOR_ALLOCATE], 0xCC);
+
+        let result = decoder.end().unwrap();
+        assert_eq!(result.len(), total_len);
+        assert_eq!(result[total_len - 1], 0xDD);
+    }
+
+    #[cfg(feature = "alloc")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub struct Inner(u32);
+
+    /// The decoder for the [`Inner`] type.
+    #[cfg(feature = "alloc")]
+    pub struct InnerDecoder(ArrayDecoder<4>);
+
+    #[cfg(feature = "alloc")]
+    impl Decoder for InnerDecoder {
+        type Output = Inner;
+        type Error = UnexpectedEofError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            self.0.push_bytes(bytes)
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> {
+            let n = u32::from_le_bytes(self.0.end()?);
+            Ok(Inner(n))
+        }
+
+        fn read_limit(&self) -> usize { self.0.read_limit() }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl Decodable for Inner {
+        type Decoder = InnerDecoder;
+        fn decoder() -> Self::Decoder { InnerDecoder(ArrayDecoder::<4>::new()) }
+    }
+
+    #[cfg(feature = "alloc")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub struct Test(Vec<Inner>);
+
+    /// The decoder for the [`Test`] type.
+    #[cfg(feature = "alloc")]
+    #[derive(Default)]
+    pub struct TestDecoder(VecDecoder<Inner>);
+
+    #[cfg(feature = "alloc")]
+    impl Decoder for TestDecoder {
+        type Output = Test;
+        type Error = VecDecoderError<UnexpectedEofError>;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            self.0.push_bytes(bytes)
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> {
+            let v = self.0.end()?;
+            Ok(Test(v))
+        }
+
+        fn read_limit(&self) -> usize { self.0.read_limit() }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl Decodable for Test {
+        type Decoder = TestDecoder;
+        fn decoder() -> Self::Decoder { TestDecoder(VecDecoder::new()) }
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn vec_decoder_empty() {
+        // Empty with a couple of arbitrary extra bytes.
+        let encoded = vec![0x00, 0xFF, 0xFF];
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = Test::decoder();
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+
+        let got = decoder.end().unwrap();
+        let want = Test(vec![]);
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn vec_decoder_one_item() {
+        let encoded = vec![0x01, 0xEF, 0xBE, 0xAD, 0xDE];
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = Test::decoder();
+        decoder.push_bytes(&mut slice).unwrap();
+
+        let got = decoder.end().unwrap();
+        let want = Test(vec![Inner(0xDEAD_BEEF)]);
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn vec_decoder_two_items() {
+        let encoded = vec![0x02, 0xEF, 0xBE, 0xAD, 0xDE, 0xBE, 0xBA, 0xFE, 0xCA];
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = Test::decoder();
+        decoder.push_bytes(&mut slice).unwrap();
+
+        let got = decoder.end().unwrap();
+        let want = Test(vec![Inner(0xDEAD_BEEF), Inner(0xCAFE_BABE)]);
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn vec_decoder_reserves_in_batches() {
+        // A small number of extra elements so we extend exactly by the remainder
+        // instead of another full batch.
+        let tail_length: usize = 11;
+
+        let element_size = core::mem::size_of::<Inner>();
+        let batch_length = MAX_VECTOR_ALLOCATE / element_size;
+        assert!(batch_length > 1);
+        let total_len = batch_length + tail_length;
+        let total_len_le = u32::try_from(total_len).expect("total_len fits u32").to_le_bytes();
+        let mut decoder = Test::decoder();
+
+        let mut prefix = vec![0xFE]; // total_len_le is a compact size of four bytes.
+        prefix.extend_from_slice(&total_len_le);
+        prefix.extend_from_slice(&0xAA_u32.to_le_bytes());
+        let mut prefix_slice = prefix.as_slice();
+        decoder.push_bytes(&mut prefix_slice).expect("length plus first element");
+        assert!(prefix_slice.is_empty());
+
+        assert_eq!(decoder.0.buffer.capacity(), batch_length);
+        assert_eq!(decoder.0.buffer.len(), 1);
+        assert_eq!(decoder.0.buffer[0], Inner(0xAA));
+
+        let fill = 0xBB_u32.to_le_bytes().repeat(batch_length - 1);
+        let mut fill_slice = fill.as_slice();
+        decoder.push_bytes(&mut fill_slice).expect("fills to batch boundary, full capacity");
+        assert!(fill_slice.is_empty());
+
+        assert_eq!(decoder.0.buffer.capacity(), batch_length);
+        assert_eq!(decoder.0.buffer.len(), batch_length);
+        assert_eq!(decoder.0.buffer[batch_length - 1], Inner(0xBB));
+
+        let mut tail = 0xCC_u32.to_le_bytes().to_vec();
+        tail.extend(0xDD_u32.to_le_bytes().repeat(tail_length - 1));
+        let mut tail_slice = tail.as_slice();
+        decoder.push_bytes(&mut tail_slice).expect("fills the remaining bytes");
+        assert!(tail_slice.is_empty());
+
+        assert_eq!(decoder.0.buffer.capacity(), batch_length + tail_length);
+        assert_eq!(decoder.0.buffer.len(), total_len);
+        assert_eq!(decoder.0.buffer[batch_length], Inner(0xCC));
+
+        let Test(result) = decoder.end().unwrap();
+        assert_eq!(result.len(), total_len);
+        assert_eq!(result[total_len - 1], Inner(0xDD));
+    }
+
+    #[cfg(feature = "alloc")]
+    fn two_fifty_six_elements() -> Test {
+        Test(iter::repeat(Inner(0xDEAD_BEEF)).take(256).collect())
+    }
+
+    #[cfg(feature = "alloc")]
+    fn two_fifty_six_elements_encoded() -> Vec<u8> {
+        [0xFD, 0x00, 0x01] // 256 encoded as a  compact size.
+            .into_iter()
+            .chain(iter::repeat(0xDEAD_BEEF_u32.to_le_bytes()).take(256).flatten())
+            .collect()
+    }
+
+    #[cfg(feature = "alloc")]
+    check_decode_one_byte_at_a_time! {
+        TestDecoder::default();
+            decode_vec, Test(vec![Inner(0xDEAD_BEEF), Inner(0xCAFE_BABE)]),
+        vec![0x02, 0xEF, 0xBE, 0xAD, 0xDE, 0xBE, 0xBA, 0xFE, 0xCA];
+            decode_vec_multi_byte_length_prefix, two_fifty_six_elements(), two_fifty_six_elements_encoded();
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn vec_decoder_one_item_plus_more_data() {
+        // One u32 plus some other bytes.
+        let encoded = vec![0x01, 0xEF, 0xBE, 0xAD, 0xDE, 0xff, 0xff, 0xff, 0xff];
+
+        let mut slice = encoded.as_slice();
+
+        let mut decoder = Test::decoder();
+        decoder.push_bytes(&mut slice).unwrap();
+
+        let got = decoder.end().unwrap();
+        let want = Test(vec![Inner(0xDEAD_BEEF)]);
+
+        assert_eq!(got, want);
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn decode_vec_from_read_unbuffered_success() {
+        let encoded = [0x01, 0xEF, 0xBE, 0xAD, 0xDE, 0xff, 0xff, 0xff, 0xff];
+        let mut cursor = Cursor::new(&encoded);
+
+        let got = crate::decode_from_read_unbuffered::<Test, _>(&mut cursor).unwrap();
+        assert_eq!(cursor.position(), 5);
+
+        let want = Test(vec![Inner(0xDEAD_BEEF)]);
+        assert_eq!(got, want);
+    }
+}
diff --git a/consensus_encoding/src/decode/mod.rs b/consensus_encoding/src/decode/mod.rs
new file mode 100644
index 0000000000..e1d3e7053f
--- /dev/null
+++ b/consensus_encoding/src/decode/mod.rs
@@ -0,0 +1,416 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Consensus Decoding Traits
+
+pub mod decoders;
+
+/// A Bitcoin object which can be consensus-decoded using a push decoder.
+///
+/// To decode something, create a [`Self::Decoder`] and push byte slices
+/// into it with [`Decoder::push_bytes`], then call [`Decoder::end`] to get the result.
+pub trait Decodable {
+    /// Associated decoder for the type.
+    type Decoder: Decoder<Output = Self>;
+    /// Constructs a "default decoder" for the type.
+    fn decoder() -> Self::Decoder;
+}
+
+/// A push decoder for a consensus-decodable object.
+pub trait Decoder: Sized {
+    /// The type that this decoder produces when decoding is complete.
+    type Output;
+    /// The error type that this decoder can produce.
+    type Error;
+
+    /// Push bytes into the decoder, consuming as much as possible.
+    ///
+    /// The slice reference will be advanced to point to the unconsumed portion.
+    /// Returns `Ok(true)` if more bytes are needed to complete decoding,
+    /// `Ok(false)` if the decoder is ready to finalize with [`Self::end`],
+    /// or `Err(error)` if parsing failed.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the provided bytes are invalid or malformed according
+    /// to the decoder's validation rules. Insufficient data (needing more
+    /// bytes) is *not* an error for this method, the decoder will simply consume
+    /// what it can and return `true` to indicate more data is needed.
+    ///
+    /// # Panics
+    ///
+    /// May panic if called after a previous call to [`Self::push_bytes`] errored.
+    #[must_use = "must check result to avoid panics on subsequent calls"]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error>;
+
+    /// Complete the decoding process and return the final result.
+    ///
+    /// This consumes the decoder and should be called when no more input
+    /// data is available.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the decoder has not received sufficient data to
+    /// complete decoding, or if the accumulated data is invalid when considered
+    /// as a complete object.
+    ///
+    /// # Panics
+    ///
+    /// May panic if called after a previous call to [`Self::push_bytes`] errored.
+    #[must_use = "must check result to avoid panics on subsequent calls"]
+    fn end(self) -> Result<Self::Output, Self::Error>;
+
+    /// Returns the maximum number of bytes this decoder can consume without over-reading.
+    ///
+    /// Returns 0 if the decoder is complete and ready to finalize with [`Self::end`].
+    /// This is used by [`decode_from_read_unbuffered`] to optimize read sizes,
+    /// avoiding both inefficient under-reads and unnecessary over-reads.
+    fn read_limit(&self) -> usize;
+}
+
+/// Decodes an object from a byte slice.
+///
+/// # Errors
+///
+/// Returns an error if the decoder encounters an error while
+/// parsing the data, including insufficient data.
+pub fn decode_from_slice<T>(bytes: &[u8]) -> Result<T, <T::Decoder as Decoder>::Error>
+where
+    T: Decodable,
+{
+    let mut decoder = T::decoder();
+    let mut remaining = bytes;
+
+    while !remaining.is_empty() {
+        if !decoder.push_bytes(&mut remaining)? {
+            break;
+        }
+    }
+
+    decoder.end()
+}
+
+/// Decodes an object from a buffered reader.
+///
+/// # Performance
+///
+/// For unbuffered readers (like [`std::fs::File`] or [`std::net::TcpStream`]),
+/// consider wrapping your reader with [`std::io::BufReader`] in order to use
+/// this function. This avoids frequent small reads, which can significantly
+/// impact performance.
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+#[cfg(feature = "std")]
+pub fn decode_from_read<T, R>(mut reader: R) -> Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: std::io::BufRead,
+{
+    let mut decoder = T::decoder();
+
+    loop {
+        let mut buffer = match reader.fill_buf() {
+            Ok(buffer) => buffer,
+            // Auto retry read for non-fatal error.
+            Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
+            Err(error) => return Err(ReadError::Io(error)),
+        };
+
+        if buffer.is_empty() {
+            // EOF, but still try to finalize the decoder.
+            return decoder.end().map_err(ReadError::Decode);
+        }
+
+        let original_len = buffer.len();
+        let need_more = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
+        let consumed = original_len - buffer.len();
+        reader.consume(consumed);
+
+        if !need_more {
+            return decoder.end().map_err(ReadError::Decode);
+        }
+    }
+}
+
+/// Decodes an object from an unbuffered reader using a fixed-size buffer.
+///
+/// For most use cases, prefer [`decode_from_read`] with a [`std::io::BufReader`].
+/// This function is only needed when you have an unbuffered reader which you
+/// cannot wrap. It will probably have worse performance.
+///
+/// # Buffer
+///
+/// Uses a fixed 4KB (4096 bytes) stack-allocated buffer that is reused across
+/// read operations. This size is a good balance between memory usage and
+/// system call efficiency for most use cases.
+///
+/// For different buffer sizes, use [`decode_from_read_unbuffered_with`].
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+#[cfg(feature = "std")]
+pub fn decode_from_read_unbuffered<T, R>(
+    reader: R,
+) -> Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: std::io::Read,
+{
+    decode_from_read_unbuffered_with::<T, R, 4096>(reader)
+}
+
+/// Decodes an object from an unbuffered reader using a custom-sized buffer.
+///
+/// For most use cases, prefer [`decode_from_read`] with a [`std::io::BufReader`].
+/// This function is only needed when you have an unbuffered reader which you
+/// cannot wrap. It will probably have worse performance.
+///
+/// # Buffer
+///
+/// The `BUFFER_SIZE` parameter controls the intermediate buffer size used for
+/// reading. The buffer is allocated on the stack (not heap) and reused across
+/// read operations. Larger buffers reduce the number of system calls, but use
+/// more memory.
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+#[cfg(feature = "std")]
+pub fn decode_from_read_unbuffered_with<T, R, const BUFFER_SIZE: usize>(
+    mut reader: R,
+) -> Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: std::io::Read,
+{
+    let mut decoder = T::decoder();
+    let mut buffer = [0u8; BUFFER_SIZE];
+
+    while decoder.read_limit() > 0 {
+        // Only read what we need, up to buffer size.
+        let clamped_buffer = &mut buffer[..decoder.read_limit().min(BUFFER_SIZE)];
+        match reader.read(clamped_buffer) {
+            Ok(0) => {
+                // EOF, but still try to finalize the decoder.
+                return decoder.end().map_err(ReadError::Decode);
+            }
+            Ok(bytes_read) => {
+                if !decoder
+                    .push_bytes(&mut &clamped_buffer[..bytes_read])
+                    .map_err(ReadError::Decode)?
+                {
+                    return decoder.end().map_err(ReadError::Decode);
+                }
+            }
+            Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => {
+                // Auto retry read for non-fatal error.
+            }
+            Err(e) => return Err(ReadError::Io(e)),
+        }
+    }
+
+    decoder.end().map_err(ReadError::Decode)
+}
+
+/// An error that can occur when reading and decoding from a buffered reader.
+#[cfg(feature = "std")]
+#[derive(Debug)]
+pub enum ReadError<D> {
+    /// An I/O error occurred while reading from the reader.
+    Io(std::io::Error),
+    /// The decoder encountered an error while parsing the data.
+    Decode(D),
+}
+
+#[cfg(feature = "std")]
+impl<D: core::fmt::Display> core::fmt::Display for ReadError<D> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "I/O error: {}", e),
+            Self::Decode(e) => write!(f, "decode error: {}", e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<D> std::error::Error for ReadError<D>
+where
+    D: core::fmt::Debug + core::fmt::Display + std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Io(e) => Some(e),
+            Self::Decode(e) => Some(e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<D> From<std::io::Error> for ReadError<D> {
+    fn from(e: std::io::Error) -> Self { Self::Io(e) }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "std")]
+    use alloc::vec::Vec;
+    #[cfg(feature = "std")]
+    use std::io::{Cursor, Read};
+
+    use super::*;
+    use crate::decode::decoders::{ArrayDecoder, UnexpectedEofError};
+
+    #[derive(Debug, PartialEq)]
+    struct TestArray([u8; 4]);
+
+    impl Decodable for TestArray {
+        type Decoder = TestArrayDecoder;
+        fn decoder() -> Self::Decoder { TestArrayDecoder { inner: ArrayDecoder::new() } }
+    }
+
+    struct TestArrayDecoder {
+        inner: ArrayDecoder<4>,
+    }
+
+    impl Decoder for TestArrayDecoder {
+        type Output = TestArray;
+        type Error = UnexpectedEofError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            self.inner.push_bytes(bytes)
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> { self.inner.end().map(TestArray) }
+
+        fn read_limit(&self) -> usize { self.inner.read_limit() }
+    }
+
+    #[test]
+    fn decode_from_slice_success() {
+        let data = [1, 2, 3, 4];
+        let result: Result<TestArray, _> = decode_from_slice(&data);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn decode_from_slice_unexpected_eof() {
+        let data = [1, 2, 3];
+        let result: Result<TestArray, _> = decode_from_slice(&data);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn decode_from_slice_extra_data() {
+        let data = [1, 2, 3, 4, 5];
+        let result: Result<TestArray, _> = decode_from_slice(&data);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_extra_data() {
+        let data = [1, 2, 3, 4, 5, 6];
+        let mut cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read(&mut cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_success() {
+        let data = [1, 2, 3, 4];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_unexpected_eof() {
+        let data = [1, 2, 3];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_trait_object() {
+        let data = [1, 2, 3, 4];
+        let mut cursor = Cursor::new(&data);
+        // Test that we can pass a trait object (&mut dyn BufRead implements BufRead).
+        let reader: &mut dyn std::io::BufRead = &mut cursor;
+        let result: Result<TestArray, _> = decode_from_read(reader);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_by_reference() {
+        let data = [1, 2, 3, 4];
+        let mut cursor = Cursor::new(&data);
+        // Test that we can pass by reference (&mut T implements BufRead when T: BufRead).
+        let result: Result<TestArray, _> = decode_from_read(&mut cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+
+        let mut buf = Vec::new();
+        let _ = cursor.read_to_end(&mut buf);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_unbuffered_success() {
+        let data = [1, 2, 3, 4];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_unbuffered_unexpected_eof() {
+        let data = [1, 2, 3];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_unbuffered_empty() {
+        let data = [];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn decode_from_read_unbuffered_extra_data() {
+        let data = [1, 2, 3, 4, 5, 6];
+        let cursor = Cursor::new(&data);
+        let result: Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+}
diff --git a/consensus_encoding/src/encode/encoders.rs b/consensus_encoding/src/encode/encoders.rs
new file mode 100644
index 0000000000..735e59298d
--- /dev/null
+++ b/consensus_encoding/src/encode/encoders.rs
@@ -0,0 +1,638 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Collection of "standard encoders".
+//!
+//! These encoders should not be used directly. Instead, when implementing the
+//! [`super::Encodable`] trait on a type, you should define a newtype around one
+//! or more of these encoders, and pass through the [`Encoder`] implementation
+//! to your newtype. This avoids leaking encoding implementation details to the
+//! users of your type.
+//!
+//! For implementing these newtypes, we provide the [`encoder_newtype`] macro.
+//!
+
+use internals::array_vec::ArrayVec;
+use internals::compact_size;
+
+use super::{Encodable, Encoder};
+
+/// The maximum length of a compact size encoding.
+const SIZE: usize = 9;
+
+/// An encoder for a single byte slice.
+pub struct BytesEncoder<'sl> {
+    sl: Option<&'sl [u8]>,
+}
+
+impl<'sl> BytesEncoder<'sl> {
+    /// Constructs a byte encoder which encodes the given byte slice, with no length prefix.
+    pub const fn without_length_prefix(sl: &'sl [u8]) -> Self { Self { sl: Some(sl) } }
+}
+
+impl Encoder for BytesEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] { self.sl.unwrap_or_default() }
+
+    fn advance(&mut self) -> bool {
+        self.sl = None;
+        false
+    }
+}
+
+/// An encoder for a single array.
+pub struct ArrayEncoder<const N: usize> {
+    arr: Option<[u8; N]>,
+}
+
+impl<const N: usize> ArrayEncoder<N> {
+    /// Constructs an encoder which encodes the array with no length prefix.
+    pub const fn without_length_prefix(arr: [u8; N]) -> Self { Self { arr: Some(arr) } }
+}
+
+impl<const N: usize> Encoder for ArrayEncoder<N> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.arr.as_ref().map(|x| &x[..]).unwrap_or_default() }
+
+    #[inline]
+    fn advance(&mut self) -> bool {
+        self.arr = None;
+        false
+    }
+}
+
+/// An encoder for a list of encodable types.
+pub struct SliceEncoder<'e, T: Encodable> {
+    /// The list of references to the objects we are encoding.
+    sl: &'e [T],
+    /// Encoder for the current object being encoded.
+    cur_enc: Option<T::Encoder<'e>>,
+}
+
+impl<'e, T: Encodable> SliceEncoder<'e, T> {
+    /// Constructs an encoder which encodes the slice _without_ adding the length prefix.
+    ///
+    /// To encode with a length prefix consider using the `Encoder2`.
+    ///
+    /// E.g, `Encoder2<CompactSizeEncoder, SliceEncoder<'e, Foo>>`.
+    pub fn without_length_prefix(sl: &'e [T]) -> Self {
+        // In this `map` call we cannot remove the closure. Seems to be a bug in the compiler.
+        // Perhaps https://github.com/rust-lang/rust/issues/102540 which is 3 years old with
+        // no replies or even an acknowledgement. We will not bother filing our own issue.
+        Self { sl, cur_enc: sl.first().map(|x| T::encoder(x)) }
+    }
+}
+
+impl<T: Encodable> Encoder for SliceEncoder<'_, T> {
+    fn current_chunk(&self) -> &[u8] {
+        // `advance` sets `cur_enc` to `None` once the slice encoder is completely exhausted.
+        self.cur_enc.as_ref().map(T::Encoder::current_chunk).unwrap_or_default()
+    }
+
+    fn advance(&mut self) -> bool {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return false;
+        };
+
+        loop {
+            // On subsequent calls, attempt to advance the current encoder and return
+            // success if this succeeds.
+            if cur.advance() {
+                return true;
+            }
+            // self.sl guaranteed to be non-empty if cur is non-None.
+            self.sl = &self.sl[1..];
+
+            // If advancing the current encoder failed, attempt to move to the next encoder.
+            if let Some(x) = self.sl.first() {
+                *cur = x.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return true;
+                }
+            } else {
+                self.cur_enc = None; // shortcut the next call to advance()
+                return false;
+            }
+        }
+    }
+}
+
+/// An encoder which encodes two objects, one after the other.
+pub struct Encoder2<A, B> {
+    enc_idx: usize,
+    enc_1: A,
+    enc_2: B,
+}
+
+impl<A, B> Encoder2<A, B> {
+    /// Constructs a new composite encoder.
+    pub const fn new(enc_1: A, enc_2: B) -> Self { Self { enc_idx: 0, enc_1, enc_2 } }
+}
+
+impl<A: Encoder, B: Encoder> Encoder for Encoder2<A, B> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] {
+        if self.enc_idx == 0 {
+            self.enc_1.current_chunk()
+        } else {
+            self.enc_2.current_chunk()
+        }
+    }
+
+    #[inline]
+    fn advance(&mut self) -> bool {
+        if self.enc_idx == 0 {
+            if !self.enc_1.advance() {
+                self.enc_idx += 1;
+            }
+            true
+        } else {
+            self.enc_2.advance()
+        }
+    }
+}
+
+// For now we implement every higher encoder by composing Encoder2s, because
+// I'm lazy and this is trivial both to write and to review. For efficiency, we
+// should eventually unroll all of these. There are only a couple of them. The
+// unrolled versions should be macro-izable, if we want to do that.
+
+/// An encoder which encodes three objects, one after the other.
+pub struct Encoder3<A, B, C> {
+    inner: Encoder2<Encoder2<A, B>, C>,
+}
+
+impl<A, B, C> Encoder3<A, B, C> {
+    /// Constructs a new composite encoder.
+    pub const fn new(enc_1: A, enc_2: B, enc_3: C) -> Self {
+        Self { inner: Encoder2::new(Encoder2::new(enc_1, enc_2), enc_3) }
+    }
+}
+
+impl<A: Encoder, B: Encoder, C: Encoder> Encoder for Encoder3<A, B, C> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.inner.current_chunk() }
+    #[inline]
+    fn advance(&mut self) -> bool { self.inner.advance() }
+}
+
+/// An encoder which encodes four objects, one after the other.
+pub struct Encoder4<A, B, C, D> {
+    inner: Encoder2<Encoder2<A, B>, Encoder2<C, D>>,
+}
+
+impl<A, B, C, D> Encoder4<A, B, C, D> {
+    /// Constructs a new composite encoder.
+    pub const fn new(enc_1: A, enc_2: B, enc_3: C, enc_4: D) -> Self {
+        Self { inner: Encoder2::new(Encoder2::new(enc_1, enc_2), Encoder2::new(enc_3, enc_4)) }
+    }
+}
+
+impl<A: Encoder, B: Encoder, C: Encoder, D: Encoder> Encoder for Encoder4<A, B, C, D> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.inner.current_chunk() }
+    #[inline]
+    fn advance(&mut self) -> bool { self.inner.advance() }
+}
+
+/// An encoder which encodes six objects, one after the other.
+pub struct Encoder6<A, B, C, D, E, F> {
+    inner: Encoder2<Encoder3<A, B, C>, Encoder3<D, E, F>>,
+}
+
+impl<A, B, C, D, E, F> Encoder6<A, B, C, D, E, F> {
+    /// Constructs a new composite encoder.
+    pub const fn new(enc_1: A, enc_2: B, enc_3: C, enc_4: D, enc_5: E, enc_6: F) -> Self {
+        Self {
+            inner: Encoder2::new(
+                Encoder3::new(enc_1, enc_2, enc_3),
+                Encoder3::new(enc_4, enc_5, enc_6),
+            ),
+        }
+    }
+}
+
+impl<A: Encoder, B: Encoder, C: Encoder, D: Encoder, E: Encoder, F: Encoder> Encoder
+    for Encoder6<A, B, C, D, E, F>
+{
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.inner.current_chunk() }
+    #[inline]
+    fn advance(&mut self) -> bool { self.inner.advance() }
+}
+
+/// Encoder for a compact size encoded integer.
+pub struct CompactSizeEncoder {
+    buf: Option<ArrayVec<u8, SIZE>>,
+}
+
+impl CompactSizeEncoder {
+    /// Constructs a new `CompactSizeEncoder`.
+    ///
+    /// Encodings are defined only for the range of u64. On systems where usize is
+    /// larger than u64, it will be possible to call this method with out-of-range
+    /// values. In such cases we will ignore the passed value and encode [`u64::MAX`].
+    /// But even on such exotic systems, we expect users to pass the length of an
+    /// in-memory object, meaning that such large values are impossible to obtain.
+    pub fn new(value: usize) -> Self {
+        let enc_value = value.try_into().unwrap_or(u64::MAX);
+        Self { buf: Some(compact_size::encode(enc_value)) }
+    }
+}
+
+impl Encoder for CompactSizeEncoder {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.buf.as_ref().map(|b| &b[..]).unwrap_or_default() }
+
+    #[inline]
+    fn advance(&mut self) -> bool {
+        self.buf = None;
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct TestBytes<'a>(&'a [u8]);
+
+    impl Encodable for TestBytes<'_> {
+        type Encoder<'s>
+            = BytesEncoder<'s>
+        where
+            Self: 's;
+
+        fn encoder(&self) -> Self::Encoder<'_> { BytesEncoder::without_length_prefix(self.0) }
+    }
+
+    struct TestArray<const N: usize>([u8; N]);
+
+    impl<const N: usize> Encodable for TestArray<N> {
+        type Encoder<'s>
+            = ArrayEncoder<N>
+        where
+            Self: 's;
+
+        fn encoder(&self) -> Self::Encoder<'_> { ArrayEncoder::without_length_prefix(self.0) }
+    }
+
+    #[test]
+    fn encode_array_with_data() {
+        // Should have one chunk with the array data, then exhausted.
+        let test_array = TestArray([1u8, 2, 3, 4]);
+        let mut encoder = test_array.encoder();
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3, 4][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_empty_array() {
+        // Empty array should have one empty chunk, then exhausted.
+        let test_array = TestArray([]);
+        let mut encoder = test_array.encoder();
+        assert!(encoder.current_chunk().is_empty());
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_byte_slice_without_prefix() {
+        // Should have one chunk with the byte data, then exhausted.
+        let obj = [1u8, 2, 3];
+        let test_bytes = TestBytes(&obj);
+        let mut encoder = test_bytes.encoder();
+
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_empty_byte_slice_without_prefix() {
+        // Should have one empty chunk, then exhausted.
+        let obj = [];
+        let test_bytes = TestBytes(&obj);
+        let mut encoder = test_bytes.encoder();
+
+        assert!(encoder.current_chunk().is_empty());
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_slice_with_elements() {
+        // Should have the element chunks, then exhausted.
+        let slice = &[TestArray([0x34, 0x12, 0x00, 0x00]), TestArray([0x78, 0x56, 0x00, 0x00])];
+        let mut encoder = SliceEncoder::without_length_prefix(slice);
+
+        assert_eq!(encoder.current_chunk(), &[0x34, 0x12, 0x00, 0x00][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x78, 0x56, 0x00, 0x00][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_empty_slice() {
+        // Should immediately be exhausted.
+        let slice: &[TestArray<4>] = &[];
+        let mut encoder = SliceEncoder::without_length_prefix(slice);
+
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_slice_with_zero_sized_arrays() {
+        // Should have empty array chunks, then exhausted.
+        let slice = &[TestArray([]), TestArray([])];
+        let mut encoder = SliceEncoder::without_length_prefix(slice);
+
+        assert!(encoder.current_chunk().is_empty());
+        // The slice advanced is optimized to skip over empty chunks.
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_two_arrays() {
+        // Should encode first array, then second array, then exhausted.
+        let enc1 = TestArray([1u8, 2]).encoder();
+        let enc2 = TestArray([3u8, 4]).encoder();
+        let mut encoder = Encoder2::new(enc1, enc2);
+
+        assert_eq!(encoder.current_chunk(), &[1u8, 2][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8, 4][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_two_empty_arrays() {
+        // Should encode first empty array, then second empty array, then exhausted.
+        let enc1 = TestArray([]).encoder();
+        let enc2 = TestArray([]).encoder();
+        let mut encoder = Encoder2::new(enc1, enc2);
+
+        assert!(encoder.current_chunk().is_empty());
+        assert!(encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_three_arrays() {
+        // Should encode three arrays in sequence, then exhausted.
+        let enc1 = TestArray([1u8]).encoder();
+        let enc2 = TestArray([2u8, 3u8]).encoder();
+        let enc3 = TestArray([4u8, 5u8, 6u8]).encoder();
+        let mut encoder = Encoder3::new(enc1, enc2, enc3);
+
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[2u8, 3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[4u8, 5u8, 6u8][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_four_arrays() {
+        // Should encode four arrays in sequence, then exhausted.
+        let enc1 = TestArray([0x10]).encoder();
+        let enc2 = TestArray([0x20]).encoder();
+        let enc3 = TestArray([0x30]).encoder();
+        let enc4 = TestArray([0x40]).encoder();
+        let mut encoder = Encoder4::new(enc1, enc2, enc3, enc4);
+
+        assert_eq!(encoder.current_chunk(), &[0x10][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x20][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x30][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x40][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_six_arrays() {
+        // Should encode six arrays in sequence, then exhausted.
+        let enc1 = TestArray([0x01]).encoder();
+        let enc2 = TestArray([0x02]).encoder();
+        let enc3 = TestArray([0x03]).encoder();
+        let enc4 = TestArray([0x04]).encoder();
+        let enc5 = TestArray([0x05]).encoder();
+        let enc6 = TestArray([0x06]).encoder();
+        let mut encoder = Encoder6::new(enc1, enc2, enc3, enc4, enc5, enc6);
+
+        assert_eq!(encoder.current_chunk(), &[0x01][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x02][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x03][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x04][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x05][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x06][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_mixed_composition_with_byte_slices() {
+        // Should encode byte slice, then array, then exhausted.
+        let enc1 = TestBytes(&[0xFF, 0xEE]).encoder();
+        let enc2 = TestArray([0xDD, 0xCC]).encoder();
+        let mut encoder = Encoder2::new(enc1, enc2);
+
+        assert_eq!(encoder.current_chunk(), &[0xFF, 0xEE][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xDD, 0xCC][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_nested_composition() {
+        // Should encode empty array, single byte array, then three byte array, then exhausted.
+        let enc1 = TestArray([]).encoder();
+        let enc2 = TestArray([0x42]).encoder();
+        let enc3 = TestArray([0x43, 0x44, 0x45]).encoder();
+        let mut encoder = Encoder3::new(enc1, enc2, enc3);
+
+        assert!(encoder.current_chunk().is_empty());
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x42][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x43, 0x44, 0x45][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_slice_with_array_composition() {
+        // Should encode slice elements, then array, then exhausted.
+        let slice = &[TestArray([0x10, 0x11]), TestArray([0x12, 0x13])];
+        let slice_enc = SliceEncoder::without_length_prefix(slice);
+        let array_enc = TestArray([0x20, 0x21]).encoder();
+        let mut encoder = Encoder2::new(slice_enc, array_enc);
+
+        assert_eq!(encoder.current_chunk(), &[0x10, 0x11][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x12, 0x13][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x20, 0x21][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_array_with_slice_composition() {
+        // Should encode header array, then slice elements, then exhausted.
+        let header = TestArray([0xFF, 0xFE]).encoder();
+        let slice = &[TestArray([0x01]), TestArray([0x02]), TestArray([0x03])];
+        let slice_enc = SliceEncoder::without_length_prefix(slice);
+        let mut encoder = Encoder2::new(header, slice_enc);
+
+        assert_eq!(encoder.current_chunk(), &[0xFF, 0xFE][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x01][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x02][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x03][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_multiple_slices_composition() {
+        // Should encode three slices in sequence, then exhausted.
+        let slice1 = &[TestArray([0xA1]), TestArray([0xA2])];
+        let slice2: &[TestArray<1>] = &[];
+        let slice3 = &[TestArray([0xC1]), TestArray([0xC2]), TestArray([0xC3])];
+
+        let enc1 = SliceEncoder::without_length_prefix(slice1);
+        let enc2 = SliceEncoder::without_length_prefix(slice2);
+        let enc3 = SliceEncoder::without_length_prefix(slice3);
+        let mut encoder = Encoder3::new(enc1, enc2, enc3);
+
+        assert_eq!(encoder.current_chunk(), &[0xA1][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xA2][..]);
+
+        // Skip the empty slice
+        assert!(encoder.advance());
+
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xC1][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xC2][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xC3][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_complex_nested_structure() {
+        // Should encode header, slice with elements, and footer with prefix, then exhausted.
+        let header = TestBytes(&[0xDE, 0xAD]).encoder();
+        let data_slice = &[TestArray([0x01, 0x02]), TestArray([0x03, 0x04])];
+        let slice_enc = SliceEncoder::without_length_prefix(data_slice);
+        let footer = TestBytes(&[0xBE, 0xEF]).encoder();
+        let mut encoder = Encoder3::new(header, slice_enc, footer);
+
+        assert_eq!(encoder.current_chunk(), &[0xDE, 0xAD][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x01, 0x02][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0x03, 0x04][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xBE, 0xEF][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+    #[test]
+    fn encode_compact_size() {
+        // 1-byte
+        let mut e = CompactSizeEncoder::new(0x10usize);
+        assert_eq!(e.current_chunk(), &[0x10][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        let mut e = CompactSizeEncoder::new(0xFCusize);
+        assert_eq!(e.current_chunk(), &[0xFC][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        // 0xFD + u16
+        let mut e = CompactSizeEncoder::new(0x00FDusize);
+        assert_eq!(e.current_chunk(), &[0xFD, 0xFD, 0x00][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        let mut e = CompactSizeEncoder::new(0x0FFFusize);
+        assert_eq!(e.current_chunk(), &[0xFD, 0xFF, 0x0F][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        // 0xFE + u32
+        let mut e = CompactSizeEncoder::new(0x0001_0000usize);
+        assert_eq!(e.current_chunk(), &[0xFE, 0x00, 0x00, 0x01, 0x00][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        let mut e = CompactSizeEncoder::new(0x0F0F_0F0Fusize);
+        assert_eq!(e.current_chunk(), &[0xFE, 0x0F, 0x0F, 0x0F, 0x0F][..]);
+        assert!(!e.advance());
+        assert!(e.current_chunk().is_empty());
+
+        // 0xFF + u64
+        // This test only runs on systems with >= 64 bit usize.
+        if core::mem::size_of::<usize>() >= 8 {
+            let mut e = CompactSizeEncoder::new(0x0000_F0F0_F0F0_F0E0u64 as usize);
+            assert_eq!(
+                e.current_chunk(),
+                &[0xFF, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x00, 0x00][..]
+            );
+            assert!(!e.advance());
+            assert!(e.current_chunk().is_empty());
+        }
+
+        // > u64::MAX encodes as u64::MAX.
+        // This test only runs on systems with > 64 bit usize.
+        if core::mem::size_of::<usize>() > 8 {
+            let mut e = CompactSizeEncoder::new((u128::from(u64::MAX) + 5) as usize);
+            assert_eq!(
+                e.current_chunk(),
+                &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF][..]
+            );
+            assert!(!e.advance());
+            assert!(e.current_chunk().is_empty());
+        }
+    }
+
+    #[test]
+    fn iter_encoder() {
+        let test_array = TestArray([1u8, 2, 3, 4]);
+        let mut iter = crate::EncodableByteIter::new(&test_array);
+        let mut byte = iter.next().unwrap();
+        assert_eq!(byte, 1u8);
+        byte = iter.next().unwrap();
+        assert_eq!(byte, 2u8);
+        byte = iter.next().unwrap();
+        assert_eq!(byte, 3u8);
+        byte = iter.next().unwrap();
+        assert_eq!(byte, 4u8);
+        let none = iter.next();
+        assert_eq!(none, None);
+    }
+}
diff --git a/consensus_encoding/src/encode/mod.rs b/consensus_encoding/src/encode/mod.rs
new file mode 100644
index 0000000000..e5c7f98bd3
--- /dev/null
+++ b/consensus_encoding/src/encode/mod.rs
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Consensus Encoding Traits
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+pub mod encoders;
+
+/// A Bitcoin object which can be consensus-encoded.
+///
+/// To encode something, use the [`Self::encoder`] method to obtain a
+/// [`Self::Encoder`], which will behave like an iterator yielding
+/// byte slices.
+pub trait Encodable {
+    /// The encoder associated with this type. Conceptually, the encoder is like
+    /// an iterator which yields byte slices.
+    type Encoder<'s>: Encoder
+    where
+        Self: 's;
+
+    /// Constructs a "default encoder" for the type.
+    fn encoder(&self) -> Self::Encoder<'_>;
+}
+
+/// An encoder for a consensus-encodable object.
+pub trait Encoder {
+    /// Yields the current encoded byteslice.
+    ///
+    /// Will always return the same value until [`Self::advance`] is called. May return an empty
+    /// list.
+    fn current_chunk(&self) -> &[u8];
+
+    /// Moves the encoder to its next state.
+    ///
+    /// Does not need to be called when the encoder is first created. (In fact, if it
+    /// is called, this will discard the first chunk of encoded data.)
+    ///
+    /// # Returns
+    ///
+    /// - `true` if the encoder has advanced to a new state and [`Self::current_chunk`] will return new data.
+    /// - `false` if the encoder is exhausted and has no more states.
+    fn advance(&mut self) -> bool;
+}
+
+/// Implements a newtype around an encoder which implements the
+/// [`Encoder`] trait by forwarding to the wrapped encoder.
+#[macro_export]
+macro_rules! encoder_newtype{
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $name:ident$(<$lt:lifetime>)?($encoder:ty);
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $name$(<$lt>)?($encoder);
+
+        impl$(<$lt>)? $crate::Encoder for $name$(<$lt>)? {
+            #[inline]
+            fn current_chunk(&self) -> &[u8] { self.0.current_chunk() }
+
+            #[inline]
+            fn advance(&mut self) -> bool { self.0.advance() }
+        }
+    }
+}
+
+/// Yields bytes from any [`Encodable`] instance.
+pub struct EncodableByteIter<'s, T: Encodable + 's> {
+    enc: T::Encoder<'s>,
+    position: usize,
+}
+
+impl<'s, T: Encodable + 's> EncodableByteIter<'s, T> {
+    /// Constructs a new byte iterator around a provided encodable.
+    pub fn new(encodable: &'s T) -> Self { Self { enc: encodable.encoder(), position: 0 } }
+}
+
+impl<'s, T: Encodable + 's> Iterator for EncodableByteIter<'s, T> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if let Some(b) = self.enc.current_chunk().get(self.position) {
+                self.position += 1;
+                return Some(*b);
+            } else if !self.enc.advance() {
+                return None;
+            }
+            self.position = 0;
+        }
+    }
+}
+
+/// Encodes an object into a vector.
+#[cfg(feature = "alloc")]
+pub fn encode_to_vec<T>(object: &T) -> Vec<u8>
+where
+    T: Encodable + ?Sized,
+{
+    let mut encoder = object.encoder();
+    let mut vec = Vec::new();
+    loop {
+        vec.extend_from_slice(encoder.current_chunk());
+        if !encoder.advance() {
+            break;
+        }
+    }
+    vec
+}
+
+/// Encodes an object to a standard I/O writer.
+///
+/// # Performance
+///
+/// This method writes data in potentially small chunks based on the encoder's
+/// internal chunking strategy. For optimal performance with unbuffered writers
+/// (like [`std::fs::File`] or [`std::net::TcpStream`]), consider wrapping your
+/// writer with [`std::io::BufWriter`].
+///
+/// # Errors
+///
+/// Returns any I/O error encountered while writing to the writer.
+#[cfg(feature = "std")]
+pub fn encode_to_writer<T, W>(object: &T, mut writer: W) -> Result<(), std::io::Error>
+where
+    T: Encodable + ?Sized,
+    W: std::io::Write,
+{
+    let mut encoder = object.encoder();
+    loop {
+        writer.write_all(encoder.current_chunk())?;
+        if !encoder.advance() {
+            break;
+        }
+    }
+    Ok(())
+}
+
+impl<T: Encoder> Encoder for Option<T> {
+    fn current_chunk(&self) -> &[u8] {
+        match self {
+            Some(encoder) => encoder.current_chunk(),
+            None => &[],
+        }
+    }
+
+    fn advance(&mut self) -> bool {
+        match self {
+            Some(encoder) => encoder.advance(),
+            None => false,
+        }
+    }
+}
diff --git a/consensus_encoding/src/lib.rs b/consensus_encoding/src/lib.rs
new file mode 100644
index 0000000000..2f5a315ba1
--- /dev/null
+++ b/consensus_encoding/src/lib.rs
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Rust Bitcoin - consensus encoding and decoding
+//!
+//! This library provides traits that can be used to encode/decode objects in a
+//! consensus-consistent way.
+//!
+
+#![no_std]
+// Coding conventions.
+#![warn(missing_docs)]
+#![warn(deprecated_in_future)]
+#![doc(test(attr(warn(unused))))]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+mod decode;
+mod encode;
+
+pub use self::decode::decoders::{
+    ArrayDecoder, CompactSizeDecoder, CompactSizeDecoderError, Decoder2, Decoder2Error, Decoder3,
+    Decoder3Error, Decoder4, Decoder4Error, Decoder6, Decoder6Error, UnexpectedEofError,
+};
+#[cfg(feature = "alloc")]
+pub use self::decode::decoders::{
+    ByteVecDecoder, ByteVecDecoderError, LengthPrefixExceedsMaxError, VecDecoder, VecDecoderError,
+};
+#[cfg(feature = "std")]
+pub use self::decode::{
+    decode_from_read, decode_from_read_unbuffered, decode_from_read_unbuffered_with, ReadError,
+};
+pub use self::decode::{decode_from_slice, Decodable, Decoder};
+#[cfg(feature = "alloc")]
+pub use self::encode::encode_to_vec;
+#[cfg(feature = "std")]
+pub use self::encode::encode_to_writer;
+pub use self::encode::encoders::{
+    ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encoder2, Encoder3, Encoder4, Encoder6,
+    SliceEncoder,
+};
+pub use self::encode::{Encodable, EncodableByteIter, Encoder};
diff --git a/consensus_encoding/tests/composition.rs b/consensus_encoding/tests/composition.rs
new file mode 100644
index 0000000000..9b180ac87f
--- /dev/null
+++ b/consensus_encoding/tests/composition.rs
@@ -0,0 +1,344 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Test composition of encoders and decoders.
+
+use bitcoin_consensus_encoding::{
+    ArrayDecoder, ArrayEncoder, BytesEncoder, Decodable, Decoder, Decoder2, Decoder2Error,
+    Decoder6, Encodable, Encoder, Encoder2, Encoder3, Encoder6, UnexpectedEofError,
+};
+
+const EMPTY: &[u8] = &[];
+
+// A simple composite type that encodes as [4 bytes] + [2 bytes].
+#[derive(Debug, PartialEq, Eq)]
+struct CompositeData {
+    first: [u8; 4],
+    second: [u8; 2],
+}
+
+impl Encodable for CompositeData {
+    type Encoder<'e> = Encoder2<ArrayEncoder<4>, ArrayEncoder<2>>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder2::new(
+            ArrayEncoder::without_length_prefix(self.first),
+            ArrayEncoder::without_length_prefix(self.second),
+        )
+    }
+}
+
+/// A unified error type for [`CompositeDataDecoder`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum CompositeError {
+    Eof(UnexpectedEofError),
+}
+
+impl From<UnexpectedEofError> for CompositeError {
+    fn from(eof: UnexpectedEofError) -> Self { Self::Eof(eof) }
+}
+
+impl core::fmt::Display for CompositeError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Eof(eof) => write!(f, "Composite error: {}", eof),
+        }
+    }
+}
+
+/// A wrapper decoder that converts the tuple output to [`CompositeData`].
+struct CompositeDataDecoder {
+    inner: Decoder2<ArrayDecoder<4>, ArrayDecoder<2>>,
+}
+
+impl CompositeDataDecoder {
+    fn new() -> Self {
+        Self { inner: Decoder2::new(ArrayDecoder::<4>::new(), ArrayDecoder::<2>::new()) }
+    }
+}
+
+impl Decoder for CompositeDataDecoder {
+    type Output = CompositeData;
+    type Error = CompositeError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(|error| match error {
+            Decoder2Error::First(e) | Decoder2Error::Second(e) => CompositeError::Eof(e),
+        })
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (first, second) = self.inner.end().map_err(|error| match error {
+            Decoder2Error::First(e) | Decoder2Error::Second(e) => CompositeError::Eof(e),
+        })?;
+        Ok(CompositeData { first, second })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+impl Decodable for CompositeData {
+    type Decoder = CompositeDataDecoder;
+
+    fn decoder() -> Self::Decoder { CompositeDataDecoder::new() }
+}
+
+#[test]
+fn composition_chain() {
+    let original = CompositeData { first: [0x01, 0x02, 0x03, 0x04], second: [0x05, 0x06] };
+    // Encode using the pull encoder.
+    let mut encoder = original.encoder();
+    let mut encoded_bytes = Vec::new();
+    loop {
+        encoded_bytes.extend_from_slice(encoder.current_chunk());
+        if !encoder.advance() {
+            break;
+        }
+    }
+    // Decode using the push decoder.
+    let mut decoder = CompositeData::decoder();
+    let mut bytes = &encoded_bytes[..];
+    let needs_more = decoder.push_bytes(&mut bytes).unwrap();
+    assert!(!needs_more, "CompositeData decoder should be ready to end");
+    assert_eq!(bytes, EMPTY);
+    let decoded = decoder.end().unwrap();
+    assert_eq!(original, decoded);
+}
+
+#[test]
+fn composition_nested() {
+    let data = b"abcdef";
+    let mut encoder6 = Encoder6::new(
+        ArrayEncoder::without_length_prefix([data[0]]),
+        ArrayEncoder::without_length_prefix([data[1]]),
+        ArrayEncoder::without_length_prefix([data[2]]),
+        ArrayEncoder::without_length_prefix([data[3]]),
+        ArrayEncoder::without_length_prefix([data[4]]),
+        ArrayEncoder::without_length_prefix([data[5]]),
+    );
+
+    let mut encoded_bytes = Vec::new();
+    loop {
+        encoded_bytes.extend_from_slice(encoder6.current_chunk());
+        if !encoder6.advance() {
+            break;
+        }
+    }
+    assert_eq!(encoded_bytes, data);
+
+    let mut decoder6: Decoder6<_, _, _, _, _, _> = Decoder6::new(
+        ArrayDecoder::<1>::new(),
+        ArrayDecoder::<1>::new(),
+        ArrayDecoder::<1>::new(),
+        ArrayDecoder::<1>::new(),
+        ArrayDecoder::<1>::new(),
+        ArrayDecoder::<1>::new(),
+    );
+    let mut bytes = &encoded_bytes[..];
+    let needs_more = decoder6.push_bytes(&mut bytes).unwrap();
+    assert!(!needs_more, "Decoder6 should be ready to end");
+    assert_eq!(bytes, EMPTY);
+    let (first, second, third, fourth, fifth, sixth) = decoder6.end().unwrap();
+    assert_eq!(first, [data[0]]);
+    assert_eq!(second, [data[1]]);
+    assert_eq!(third, [data[2]]);
+    assert_eq!(fourth, [data[3]]);
+    assert_eq!(fifth, [data[4]]);
+    assert_eq!(sixth, [data[5]]);
+}
+
+#[test]
+fn composition_extra_bytes() {
+    // Test that Decoder2 consumes exactly what it needs and leaves extra bytes unconsumed.
+    let mut decoder2: Decoder2<_, _> =
+        Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
+    let mut bytes = &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08][..];
+    let original_len = bytes.len();
+
+    let needs_more = decoder2.push_bytes(&mut bytes).unwrap();
+    assert!(!needs_more, "Decoder2 should be ready to end after consuming all needed bytes");
+
+    let consumed = original_len - bytes.len();
+    assert_eq!(consumed, 5, "Decoder2 should consume exactly 5 bytes");
+    assert_eq!(bytes.len(), 3, "3 bytes should remain unconsumed");
+    assert_eq!(bytes, &[0x06, 0x07, 0x08], "Remaining bytes should be the last 3");
+
+    let (first, second) = decoder2.end().unwrap();
+    assert_eq!(first, [0x01, 0x02], "First decoder should get first 2 bytes");
+    assert_eq!(second, [0x03, 0x04, 0x05], "Second decoder should get next 3 bytes");
+}
+
+#[test]
+#[allow(clippy::too_many_lines)]
+fn composition_error_unification() {
+    // Demonstrates how decoders unify error types into
+    // a single target error type through `From` conversions.
+
+    /// Error for the lower level decoders.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    enum NestedError {
+        BadChecksum,
+        UnexpectedEof(UnexpectedEofError),
+    }
+
+    impl From<UnexpectedEofError> for NestedError {
+        fn from(eof: UnexpectedEofError) -> Self { Self::UnexpectedEof(eof) }
+    }
+
+    /// Error for top level encoder.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    enum TopLevelError {
+        UnexpectedEof(UnexpectedEofError),
+        Validation(NestedError),
+    }
+
+    impl From<UnexpectedEofError> for TopLevelError {
+        fn from(eof: UnexpectedEofError) -> Self { Self::UnexpectedEof(eof) }
+    }
+
+    impl From<NestedError> for TopLevelError {
+        fn from(err: NestedError) -> Self {
+            match err {
+                NestedError::UnexpectedEof(eof) => Self::UnexpectedEof(eof),
+                NestedError::BadChecksum => Self::Validation(err),
+            }
+        }
+    }
+
+    /// A test composite decoder.
+    struct HeaderDecoder {
+        inner: Decoder2<ArrayDecoder<1>, ArrayDecoder<1>>,
+    }
+
+    impl HeaderDecoder {
+        fn new() -> Self {
+            Self { inner: Decoder2::new(ArrayDecoder::<1>::new(), ArrayDecoder::<1>::new()) }
+        }
+    }
+
+    impl Decoder for HeaderDecoder {
+        type Output = ([u8; 1], [u8; 1]);
+        type Error = NestedError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            self.inner.push_bytes(bytes).map_err(|error| match error {
+                Decoder2Error::First(e) | Decoder2Error::Second(e) => NestedError::from(e),
+            })
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> {
+            let (first, second) = self.inner.end().map_err(|error| match error {
+                Decoder2Error::First(e) | Decoder2Error::Second(e) => NestedError::from(e),
+            })?;
+            Ok((first, second))
+        }
+
+        fn read_limit(&self) -> usize { self.inner.read_limit() }
+    }
+
+    /// Another test composite decoder.
+    struct PayloadDecoder {
+        inner: ArrayDecoder<4>,
+    }
+
+    impl PayloadDecoder {
+        fn new() -> Self { Self { inner: ArrayDecoder::<4>::new() } }
+    }
+
+    impl Decoder for PayloadDecoder {
+        type Output = [u8; 4];
+        type Error = TopLevelError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            Ok(self.inner.push_bytes(bytes)?)
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> {
+            let result = self.inner.end()?;
+            Ok(result)
+        }
+
+        fn read_limit(&self) -> usize { self.inner.read_limit() }
+    }
+
+    /// A decoder which can fail.
+    struct FailingDecoder {
+        inner: ArrayDecoder<1>,
+        should_fail: bool,
+    }
+
+    impl FailingDecoder {
+        fn new(should_fail: bool) -> Self { Self { inner: ArrayDecoder::<1>::new(), should_fail } }
+    }
+
+    impl Decoder for FailingDecoder {
+        type Output = [u8; 1];
+        type Error = NestedError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+            self.inner.push_bytes(bytes).map_err(NestedError::from)
+        }
+
+        fn end(self) -> Result<Self::Output, Self::Error> {
+            if self.should_fail {
+                Err(NestedError::BadChecksum)
+            } else {
+                self.inner.end().map_err(NestedError::from)
+            }
+        }
+
+        fn read_limit(&self) -> usize { self.inner.read_limit() }
+    }
+
+    // A multi-layer, nested, decoder structure with a unified top level error type.
+    let mut nested_decoder = Decoder6::new(
+        HeaderDecoder::new(),
+        PayloadDecoder::new(),
+        ArrayDecoder::<1>::new(),
+        HeaderDecoder::new(),
+        PayloadDecoder::new(),
+        ArrayDecoder::<2>::new(),
+    );
+
+    let test_data = b"abcdefghijklmno";
+    let mut bytes = &test_data[..];
+    let push_result = nested_decoder.push_bytes(&mut bytes);
+    assert!(push_result.is_ok(), "push_bytes should succeed, got error: {:?}", push_result.err());
+    let end_result = nested_decoder.end();
+    assert!(end_result.is_ok(), "end should succeed, got error: {:?}", end_result.err());
+
+    // Test error during decoding.
+    let mut failing_decoder: Decoder2<FailingDecoder, ArrayDecoder<1>> =
+        Decoder2::new(FailingDecoder::new(true), ArrayDecoder::<1>::new());
+    let test_data = b"ab";
+    let mut bytes = &test_data[..];
+    let push_result = failing_decoder.push_bytes(&mut bytes);
+    assert!(push_result.is_err(), "push_bytes should fail when first decoder fails in end()");
+    assert!(
+        matches!(push_result.as_ref().unwrap_err(), Decoder2Error::First(NestedError::BadChecksum)),
+        "Expected Decoder2Error::First(NestedError::BadChecksum), got {:?}",
+        push_result.unwrap_err()
+    );
+}
+
+#[test]
+fn empty_encoders() {
+    let bytes = [0x01, 2, 3, 4];
+    let mut encoder = Encoder3::new(
+        BytesEncoder::without_length_prefix(&bytes[..2]),
+        BytesEncoder::without_length_prefix(&[]),
+        BytesEncoder::without_length_prefix(&bytes[2..]),
+    );
+
+    assert_eq!(encoder.current_chunk(), &[1, 2][..]);
+    assert!(encoder.advance());
+
+    // Still have to advance over empty slice.
+    assert!(encoder.current_chunk().is_empty());
+    assert!(encoder.advance());
+
+    assert_eq!(encoder.current_chunk(), &[3, 4][..]);
+    assert!(!encoder.advance());
+
+    // Exhausted.
+    assert!(encoder.current_chunk().is_empty());
+}
diff --git a/consensus_encoding/tests/decode.rs b/consensus_encoding/tests/decode.rs
new file mode 100644
index 0000000000..b1c0fed90c
--- /dev/null
+++ b/consensus_encoding/tests/decode.rs
@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Integration tests for decode module.
+
+use bitcoin_consensus_encoding::{
+    ArrayDecoder, CompactSizeDecoder, Decoder, Decoder2, UnexpectedEofError,
+};
+
+const EMPTY: &[u8] = &[];
+
+#[test]
+fn decode_array_excess_data_ignored() {
+    let mut decoder = ArrayDecoder::<4>::new();
+    let mut data = &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "ArrayDecoder should be complete after consuming all needed bytes");
+    assert_eq!(data, &[0x05, 0x06]);
+    let result = decoder.end().unwrap();
+    assert_eq!(result, [0x01, 0x02, 0x03, 0x04]);
+}
+
+#[test]
+fn decode_array_streaming_behavior() {
+    let mut decoder = ArrayDecoder::<4>::new();
+
+    let mut data = &[0x01][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "ArrayDecoder should need more data after 1 byte");
+    assert_eq!(data, EMPTY);
+
+    let mut data = &[0x02, 0x03][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "ArrayDecoder should need more data after 3 bytes");
+    assert_eq!(data, EMPTY);
+
+    let mut data = &[0x04, 0x05, 0x06][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "ArrayDecoder should be complete after 4 bytes");
+    assert_eq!(data, &[0x05, 0x06]);
+
+    let result = decoder.end().unwrap();
+    assert_eq!(result, [0x01, 0x02, 0x03, 0x04]);
+}
+
+#[test]
+fn decode_array_insufficient_data_error() {
+    let mut decoder = ArrayDecoder::<5>::new();
+    let mut data = &[0xAA, 0xBB][..];
+
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "ArrayDecoder should need more data after 2 bytes for 5-byte array");
+    assert_eq!(data, EMPTY);
+
+    let err = decoder.end().unwrap_err();
+    assert!(matches!(err, UnexpectedEofError { .. }));
+}
+
+#[test]
+fn decode_array_zero_size() {
+    // Test zero-sized array decoder which doesn't consume any bytes.
+    let mut decoder = ArrayDecoder::<0>::new();
+    let mut data = &[0x01, 0x02, 0x03][..];
+
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "zero-sized ArrayDecoder should not need data");
+    assert_eq!(data, &[0x01, 0x02, 0x03]);
+    let result = decoder.end().unwrap();
+    assert_eq!(result, [0u8; 0]);
+
+    // read_limit should be 0.
+    let decoder = ArrayDecoder::<0>::new();
+    assert_eq!(decoder.read_limit(), 0);
+}
+
+#[test]
+fn decode_array_empty_slice_push() {
+    // Test pushing empty slices to ArrayDecoder.
+    let mut decoder = ArrayDecoder::<3>::new();
+    let mut empty_data = &[][..];
+
+    let needs_more = decoder.push_bytes(&mut empty_data).unwrap();
+    assert!(needs_more, "decoder should still need data after empty push");
+    assert_eq!(empty_data, &[0u8; 0]);
+    assert_eq!(decoder.read_limit(), 3);
+}
+
+#[test]
+fn decode_decoder2_state_transitions() {
+    // Test the state transition point boundry in Decoder2.
+    let mut decoder: Decoder2<ArrayDecoder<2>, ArrayDecoder<3>> =
+        Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
+
+    assert_eq!(decoder.read_limit(), 5);
+    let mut data = &[0x01, 0x02][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "should need more data for second decoder");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+
+    assert_eq!(decoder.read_limit(), 3);
+    let mut more_data = &[0x03, 0x04, 0x05][..];
+    let needs_more = decoder.push_bytes(&mut more_data).unwrap();
+    assert!(!needs_more, "should not need more data after completing both decoders");
+    assert_eq!(more_data.len(), 0, "all data should be consumed");
+
+    assert_eq!(decoder.read_limit(), 0);
+    let (first_result, second_result) = decoder.end().unwrap();
+    assert_eq!(first_result, [0x01, 0x02]);
+    assert_eq!(second_result, [0x03, 0x04, 0x05]);
+}
+
+#[test]
+fn decode_decoder2_read_limit_with_exhausted() {
+    // Test read_limit calculation when first decoder needs 0 bytes.
+    let decoder1: Decoder2<ArrayDecoder<0>, ArrayDecoder<5>> =
+        Decoder2::new(ArrayDecoder::<0>::new(), ArrayDecoder::<5>::new());
+    assert_eq!(decoder1.read_limit(), 5);
+
+    let mut decoder2: Decoder2<ArrayDecoder<2>, ArrayDecoder<3>> =
+        Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
+    let mut data = &[0x01, 0x02][..];
+    let needs_more = decoder2.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "should need more data for second decoder");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+    assert_eq!(decoder2.read_limit(), 3);
+}
+
+#[test]
+fn decode_compact_size_read_limit_transitions() {
+    // Test read_limit behavior during compact size decoding.
+    let mut decoder = CompactSizeDecoder::default();
+
+    assert_eq!(decoder.read_limit(), 1);
+    let mut data = &[0xFD][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "should need more data after seeing 0xFD");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+
+    assert_eq!(decoder.read_limit(), 2);
+    let mut data = &[0x00][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(needs_more, "should still need one more byte");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+    assert_eq!(decoder.read_limit(), 1);
+
+    let mut data = &[0x01][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "should not need more data");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+    assert_eq!(decoder.read_limit(), 0);
+
+    let result = decoder.end().unwrap();
+    assert_eq!(result, 256);
+}
+
+#[test]
+fn decode_compact_size_single_byte_read_limit() {
+    // Test read_limit for single-byte compact size.
+    let mut decoder = CompactSizeDecoder::default();
+
+    assert_eq!(decoder.read_limit(), 1);
+    let mut data = &[0x42][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "single-byte value should be complete");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+    assert_eq!(decoder.read_limit(), 0);
+    let result = decoder.end().unwrap();
+    assert_eq!(result, 66);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn decode_byte_vec_decoder_empty() {
+    // Test decoding empty byte vector, with length prefix of 0.
+    use bitcoin_consensus_encoding::{ByteVecDecoder, Decoder};
+
+    let mut decoder = ByteVecDecoder::new();
+    let mut data = &[0x00][..];
+    let needs_more = decoder.push_bytes(&mut data).unwrap();
+    assert!(!needs_more, "decoder should not need more data for empty vector");
+    assert_eq!(data.len(), 0, "all data should be consumed");
+    assert_eq!(decoder.read_limit(), 0);
+    let result = decoder.end().unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn decode_byte_vec_decoder_does_not_overconsume() {
+    use bitcoin_consensus_encoding::ByteVecDecoder;
+
+    let mut decoder = ByteVecDecoder::new();
+    let mut data = &[0x02, 0xAA, 0xBB, 0xCC, 0xDD][..];
+    assert!(!decoder.push_bytes(&mut data).unwrap());
+    assert_eq!(data, &[0xCC, 0xDD][..]);
+    assert_eq!(decoder.end().unwrap(), vec![0xAA, 0xBB]);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn decode_byte_vec_decoder_does_not_overconsume_on_second_chunk() {
+    use bitcoin_consensus_encoding::ByteVecDecoder;
+
+    // First chunk prefix declares 4 payload bytes and provides the first one.
+    let mut first_chunk: &[u8] = &[0x04, 0xAA];
+    // Second chunk provides the remaining 3 payload bytes plus two trailing bytes.
+    let mut second_chunk: &[u8] = &[0xBB, 0xCC, 0xDD, 0x11, 0x22];
+
+    let mut decoder = ByteVecDecoder::new();
+
+    assert!(decoder.push_bytes(&mut first_chunk).unwrap());
+    assert!(first_chunk.is_empty());
+
+    let needs_more = decoder.push_bytes(&mut second_chunk).unwrap();
+    assert!(!needs_more);
+    assert_eq!(second_chunk, &[0x11, 0x22][..]);
+
+    let decoded_vec = decoder.end().unwrap();
+    assert_eq!(decoded_vec, vec![0xAA, 0xBB, 0xCC, 0xDD]);
+}
diff --git a/consensus_encoding/tests/encode.rs b/consensus_encoding/tests/encode.rs
new file mode 100644
index 0000000000..f86b63ba6d
--- /dev/null
+++ b/consensus_encoding/tests/encode.rs
@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Tests for encoder free functions.
+
+#[cfg(feature = "std")]
+use std::io::{Cursor, Write};
+
+use bitcoin_consensus_encoding::{
+    ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encoder, Encoder2,
+};
+#[cfg(feature = "alloc")]
+use bitcoin_consensus_encoding::{Encodable, SliceEncoder};
+
+// Simple test type that implements Encodable.
+#[cfg(feature = "alloc")]
+struct TestData(u32);
+
+#[cfg(feature = "alloc")]
+impl Encodable for TestData {
+    type Encoder<'s>
+        = ArrayEncoder<4>
+    where
+        Self: 's;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        ArrayEncoder::without_length_prefix(self.0.to_le_bytes())
+    }
+}
+
+// Test with a type that creates an empty encoder.
+#[cfg(feature = "alloc")]
+struct EmptyData;
+
+#[cfg(feature = "alloc")]
+impl Encodable for EmptyData {
+    type Encoder<'s>
+        = ArrayEncoder<0>
+    where
+        Self: 's;
+
+    fn encoder(&self) -> Self::Encoder<'_> { ArrayEncoder::without_length_prefix([]) }
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn encode_std_writer() {
+    let data = TestData(0x1234_5678);
+
+    let mut cursor = Cursor::new(Vec::new());
+    bitcoin_consensus_encoding::encode_to_writer(&data, &mut cursor).unwrap();
+
+    let result = cursor.into_inner();
+    assert_eq!(result, vec![0x78, 0x56, 0x34, 0x12]);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_vec() {
+    let data = TestData(0xDEAD_BEEF);
+    let vec = bitcoin_consensus_encoding::encode_to_vec(&data);
+    assert_eq!(vec, vec![0xEF, 0xBE, 0xAD, 0xDE]);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_vec_empty_data() {
+    let data = EmptyData;
+    let result = bitcoin_consensus_encoding::encode_to_vec(&data);
+    assert!(result.is_empty());
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn encode_std_writer_empty_data() {
+    let data = EmptyData;
+    let mut cursor = Cursor::new(Vec::new());
+    bitcoin_consensus_encoding::encode_to_writer(&data, &mut cursor).unwrap();
+
+    let result = cursor.into_inner();
+    assert!(result.is_empty());
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn encode_std_writer_io_error() {
+    // Test writer that always fails.
+    struct FailingWriter;
+
+    impl Write for FailingWriter {
+        fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
+            Err(std::io::Error::other("test error"))
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> { Ok(()) }
+    }
+
+    let data = TestData(0x1234_5678);
+    let mut writer = FailingWriter;
+
+    let result = bitcoin_consensus_encoding::encode_to_writer(&data, &mut writer);
+
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::Other);
+}
+
+#[test]
+fn encode_newtype_lifetime_flexibility() {
+    // Test that the encoder_newtype macro allows different lifetime names.
+
+    bitcoin_consensus_encoding::encoder_newtype! {
+        pub struct CustomEncoder<'data>(BytesEncoder<'data>);
+    }
+    bitcoin_consensus_encoding::encoder_newtype! {
+        pub struct NoLifetimeEncoder(ArrayEncoder<4>);
+    }
+
+    let test_data = b"hello world";
+    let custom_encoder = CustomEncoder(BytesEncoder::without_length_prefix(test_data));
+    let no_lifetime_encoder = NoLifetimeEncoder(ArrayEncoder::without_length_prefix([1, 2, 3, 4]));
+
+    assert_eq!(custom_encoder.current_chunk(), test_data.as_slice());
+    assert_eq!(no_lifetime_encoder.current_chunk(), &[1, 2, 3, 4][..]);
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_slice_encoder_mixed_empty_and_data() {
+    // Test SliceEncoder behavior with mixed empty and non-empty elements.
+    struct TestBytes(Vec<u8>);
+
+    impl Encodable for TestBytes {
+        type Encoder<'s>
+            = BytesEncoder<'s>
+        where
+            Self: 's;
+
+        fn encoder(&self) -> Self::Encoder<'_> { BytesEncoder::without_length_prefix(&self.0) }
+    }
+
+    let slice = &[TestBytes(vec![]), TestBytes(vec![1, 2]), TestBytes(vec![]), TestBytes(vec![3])];
+
+    let mut encoder = SliceEncoder::without_length_prefix(slice);
+
+    assert!(encoder.current_chunk().is_empty());
+    assert!(encoder.advance());
+    assert_eq!(encoder.current_chunk(), &[1, 2]);
+    assert!(encoder.advance());
+    assert_eq!(encoder.current_chunk(), &[3]);
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+}
+
+#[test]
+fn encode_compact_size_boundary_values() {
+    // Test CompactSizeEncoder with boundary values.
+    let mut encoder = CompactSizeEncoder::new(252usize);
+    assert_eq!(encoder.current_chunk(), &[252]);
+    assert!(!encoder.advance());
+
+    let mut encoder = CompactSizeEncoder::new(253usize);
+    assert_eq!(encoder.current_chunk(), &[0xFD, 253, 0]);
+    assert!(!encoder.advance());
+
+    let mut encoder = CompactSizeEncoder::new(0x10000usize);
+    assert_eq!(encoder.current_chunk(), &[0xFE, 0, 0, 1, 0]);
+    assert!(!encoder.advance());
+
+    let mut encoder = CompactSizeEncoder::new(0usize);
+    assert_eq!(encoder.current_chunk(), &[0]);
+    assert!(!encoder.advance());
+}
+
+#[test]
+fn encode_encoder2_with_first_empty_encoder() {
+    // Test Encoder2 when first encoder produces no data.
+    let enc1 = ArrayEncoder::<0>::without_length_prefix([]);
+    let enc2 = ArrayEncoder::<3>::without_length_prefix([1, 2, 3]);
+
+    let mut encoder = Encoder2::new(enc1, enc2);
+
+    assert!(encoder.current_chunk().is_empty());
+    assert!(encoder.advance());
+    assert_eq!(encoder.current_chunk(), &[1, 2, 3]);
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+}
+
+#[test]
+fn encode_encoder_advance_multiple_times_when_exhausted() {
+    // Test that calling advance() multiple times on exhausted encoder is safe.
+    let mut encoder = ArrayEncoder::<2>::without_length_prefix([10, 20]);
+
+    assert_eq!(encoder.current_chunk(), &[10, 20]);
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+    assert!(!encoder.advance());
+    assert!(!encoder.advance());
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+}
+
+#[test]
+fn encode_option_encoder_some() {
+    use bitcoin_consensus_encoding::Encoder;
+
+    let mut encoder = Some(ArrayEncoder::<3>::without_length_prefix([1, 2, 3]));
+    assert_eq!(encoder.current_chunk(), &[1, 2, 3]);
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+}
+
+#[test]
+fn encode_option_encoder_none() {
+    use bitcoin_consensus_encoding::Encoder;
+
+    let mut encoder: Option<ArrayEncoder<3>> = None;
+    assert!(encoder.current_chunk().is_empty());
+    assert!(!encoder.advance());
+    assert!(encoder.current_chunk().is_empty());
+}
diff --git a/consensus_encoding/tests/iter.rs b/consensus_encoding/tests/iter.rs
new file mode 100644
index 0000000000..5c8c114ea7
--- /dev/null
+++ b/consensus_encoding/tests/iter.rs
@@ -0,0 +1,59 @@
+use bitcoin_consensus_encoding::{ArrayEncoder, Encodable, EncodableByteIter, Encoder2};
+use hex::BytesToHexIter;
+
+struct TestArray<const N: usize>([u8; N]);
+
+impl<const N: usize> Encodable for TestArray<N> {
+    type Encoder<'s>
+        = ArrayEncoder<N>
+    where
+        Self: 's;
+
+    fn encoder(&self) -> Self::Encoder<'_> { ArrayEncoder::without_length_prefix(self.0) }
+}
+
+struct TestCatArray<const N: usize, const M: usize>([u8; N], [u8; M]);
+
+impl<const N: usize, const M: usize> Encodable for TestCatArray<N, M> {
+    type Encoder<'s>
+        = Encoder2<ArrayEncoder<N>, ArrayEncoder<M>>
+    where
+        Self: 's;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder2::new(
+            ArrayEncoder::without_length_prefix(self.0),
+            ArrayEncoder::without_length_prefix(self.1),
+        )
+    }
+}
+
+#[test]
+fn hex_iter() {
+    let data = TestArray([255u8, 240, 9, 135]);
+    let byte_iter = EncodableByteIter::new(&data);
+    let mut iter = BytesToHexIter::new(byte_iter, hex::Case::Upper);
+
+    let expect_str = "FFF00987";
+    for byte in expect_str.chars() {
+        let iter_byte = iter.next().unwrap();
+        assert_eq!(iter_byte, byte);
+    }
+    let none = iter.next();
+    assert_eq!(none, None);
+}
+
+#[test]
+fn hex_iter_cat_encoder() {
+    let data = TestCatArray([222u8, 173], [190u8, 239]);
+    let byte_iter = EncodableByteIter::new(&data);
+    let mut iter = BytesToHexIter::new(byte_iter, hex::Case::Lower);
+
+    let expect_str = "deadbeef";
+    for byte in expect_str.chars() {
+        let iter_byte = iter.next().unwrap();
+        assert_eq!(iter_byte, byte);
+    }
+    let none = iter.next();
+    assert_eq!(none, None);
+}
diff --git a/consensus_encoding/tests/wrappers.rs b/consensus_encoding/tests/wrappers.rs
new file mode 100644
index 0000000000..674c022b94
--- /dev/null
+++ b/consensus_encoding/tests/wrappers.rs
@@ -0,0 +1,134 @@
+//! Test using wrapper types as we expect the lib to be used.
+
+#![cfg(feature = "std")]
+
+use bitcoin_consensus_encoding as encoding;
+use encoding::{ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encodable, Encoder2, SliceEncoder};
+
+encoding::encoder_newtype! {
+    /// An encoder that uses an inner `ArrayEncoder`.
+    pub struct TestArrayEncoder(ArrayEncoder<4>);
+}
+
+encoding::encoder_newtype! {
+    /// An encoder that uses an inner `BytesEncoder`.
+    pub struct TestBytesEncoder<'e>(BytesEncoder<'e>);
+}
+
+#[test]
+fn array_encoder() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(u32);
+
+    impl Encodable for Test {
+        type Encoder<'e> = TestArrayEncoder;
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestArrayEncoder(ArrayEncoder::without_length_prefix(self.0.to_le_bytes()))
+        }
+    }
+
+    let t = Test(0xcafe_babe); // Encodes using an array.
+
+    let want = [0xbe, 0xba, 0xfe, 0xca];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn bytes_encoder_without_length_prefix() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(Vec<u8>);
+
+    impl Encodable for Test {
+        type Encoder<'e>
+            = TestBytesEncoder<'e>
+        where
+            Self: 'e;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestBytesEncoder(BytesEncoder::without_length_prefix(self.0.as_ref()))
+        }
+    }
+
+    let t = Test(vec![0xca, 0xfe]);
+
+    let want = [0xca, 0xfe];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn two_encoder() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test {
+        a: Vec<u8>,
+        b: Vec<u8>,
+    }
+
+    impl Encodable for Test {
+        type Encoder<'e> = Encoder2<TestBytesEncoder<'e>, TestBytesEncoder<'e>>;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            let a = TestBytesEncoder(BytesEncoder::without_length_prefix(self.a.as_ref()));
+            let b = TestBytesEncoder(BytesEncoder::without_length_prefix(self.b.as_ref()));
+
+            Encoder2::new(a, b)
+        }
+    }
+
+    let t = Test { a: vec![0xca, 0xfe], b: (vec![0xba, 0xbe]) };
+
+    let want = [0xca, 0xfe, 0xba, 0xbe];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn slice_encoder() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(Vec<Inner>);
+
+    encoding::encoder_newtype! {
+        /// An encoder that uses an inner `SliceEncoder`.
+        pub struct TestEncoder<'e>(Encoder2<CompactSizeEncoder, SliceEncoder<'e, Inner>>);
+    }
+
+    impl Encodable for Test {
+        type Encoder<'a>
+            = TestEncoder<'a>
+        where
+            Self: 'a;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestEncoder(Encoder2::new(
+                CompactSizeEncoder::new(self.0.len()),
+                SliceEncoder::without_length_prefix(&self.0),
+            ))
+        }
+    }
+
+    #[derive(Debug, Default, Clone)]
+    pub struct Inner(u32);
+
+    encoding::encoder_newtype! {
+        /// The encoder for the [`Inner`] type.
+        pub struct InnerArrayEncoder(ArrayEncoder<4>);
+    }
+
+    impl Encodable for Inner {
+        type Encoder<'e> = InnerArrayEncoder;
+        fn encoder(&self) -> Self::Encoder<'_> {
+            // Big-endian to make reading the test assertion easier.
+            InnerArrayEncoder(ArrayEncoder::without_length_prefix(self.0.to_be_bytes()))
+        }
+    }
+
+    let t = Test(vec![Inner(0xcafe_babe), Inner(0xdead_beef)]);
+    let encoded = encoding::encode_to_vec(&t);
+
+    let want = [0x02, 0xca, 0xfe, 0xba, 0xbe, 0xde, 0xad, 0xbe, 0xef];
+    assert_eq!(encoded, want);
+}
diff --git a/contrib/check-for-api-changes.sh b/contrib/check-for-api-changes.sh
index 3bfe415715..c650f856de 100755
--- a/contrib/check-for-api-changes.sh
+++ b/contrib/check-for-api-changes.sh
@@ -9,14 +9,14 @@ set -euo pipefail
 REPO_DIR=$(git rev-parse --show-toplevel)
 API_DIR="$REPO_DIR/api"
 
-NIGHTLY=$(cat nightly-version)
+NIGHTLY=$(cat "$REPO_DIR/nightly-version")
 # Our docs have broken intra doc links if all features are not enabled.
 RUSTDOCFLAGS="-A rustdoc::broken_intra_doc_links"
 
 # `sort -n -u` doesn't work for some reason.
 SORT="sort --numeric-sort"
 
-# Sort order is effected by locale. See `man sort`.
+# Sort order is affected by locale. See `man sort`.
 # > Set LC_ALL=C to get the traditional sort order that uses native byte values.
 export LC_ALL=C
 
@@ -24,10 +24,22 @@ main() {
     need_nightly
     need_cargo_public_api
 
-    generate_api_files "hashes"
-    generate_api_files "io"
-    generate_api_files "primitives"
+    # If script is running in CI the recent lock file is copied into place
+    # already by the github action job. Locally be kind to the environment.
+    if [ "${GITHUB_ACTIONS:-}" != "true" ]; then
+        [ -f "Cargo.lock" ] && mv Cargo.lock Cargo.lock.tmp
+        cp Cargo-recent.lock Cargo.lock
+    fi
+
+    # Just check crates that are stabilising.
+    generate_api_files "consensus_encoding"
     generate_api_files "units"
+    generate_api_files "primitives"
+
+    # Check crates under the stabilising crates
+    generate_api_files "internals"
+
+    [ -f "Cargo.lock.tmp" ] && mv Cargo.lock.tmp Cargo.lock
 
     check_for_changes
 }
@@ -67,12 +79,12 @@ check_for_changes() {
 
 # Run cargo when --all-features is not used.
 run_cargo() {
-    RUSTDOCFLAGS="$RUSTDOCFLAGS" cargo +"$NIGHTLY" public-api --simplified "$@"
+    RUSTDOCFLAGS="$RUSTDOCFLAGS" cargo +"$NIGHTLY" --locked public-api --simplified "$@"
 }
 
 # Run cargo with all features enabled.
 run_cargo_all_features() {
-    cargo +"$NIGHTLY" public-api --simplified --all-features
+    cargo +"$NIGHTLY" --locked public-api --simplified --all-features
 }
 
 need_nightly() {
diff --git a/contrib/check-for-policy-violations.sh b/contrib/check-for-policy-violations.sh
new file mode 100755
index 0000000000..c9b9be4428
--- /dev/null
+++ b/contrib/check-for-policy-violations.sh
@@ -0,0 +1,76 @@
+#!/bin/bash
+#
+# Check if PR abides by our policy.
+
+set -euo pipefail
+
+# When running script locally the name used for the `github.com/rust-bitcoin/rust-bitcoin` remote.
+REMOTE="upstream"
+
+main() {
+    check_required_commands
+
+    if low_level_import_usage; then
+        err "Please do not import directly from low level crates, import using 'use crate::' instead"
+    fi
+}
+
+# Enforces import policy.
+#
+# See `./policy.md` section: `### On re-exports`.
+# Greps patch for imports that violate the policy, returns true if an
+# violations are found.
+low_level_import_usage() {
+    local crates=("units" "primitives")
+    local found_violation=false
+    local violations;
+
+    # Determine the base branch - common CI environment variables.
+    local base_branch="$REMOTE/master"
+    if [[ -n "${GITHUB_BASE_REF:-}" ]]; then
+        base_branch="$GITHUB_BASE_REF"
+    elif [[ -n "${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-}" ]]; then
+        base_branch="$CI_MERGE_REQUEST_TARGET_BRANCH_NAME"
+    fi
+
+    for crate in "${crates[@]}"; do
+        violations=$(git diff "$base_branch"...HEAD -- '*.rs' | grep "^+" | grep -E "use ${crate}::" | grep -v "pub use ${crate}::" || true)
+        if [[ -n "$violations" ]]; then
+            say_err "invalid import statement: '${violations:1}'"
+            found_violation=true
+        fi
+    done
+
+    $found_violation
+}
+
+# Check all the commands we use are present in the current environment.
+check_required_commands() {
+    need_cmd grep
+    need_cmd git
+}
+
+say() {
+    echo "policy: $1"
+}
+
+say_err() {
+    say "$1" >&2
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+need_cmd() {
+    if ! command -v "$1" > /dev/null 2>&1
+    then err "need '$1' (command not found)"
+    fi
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/contrib/ensure-maintainer-tools.sh b/contrib/ensure-maintainer-tools.sh
new file mode 100755
index 0000000000..fdb1455202
--- /dev/null
+++ b/contrib/ensure-maintainer-tools.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+#
+# Ensure maintainer tools are available locally for CI task execution.
+
+set -euo pipefail
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+MAINTAINER_TOOLS_REF=$(cat "$REPO_DIR/maintainer-tools-version")
+
+cd "$REPO_DIR"
+
+if [ ! -d ".maintainer-tools" ]; then
+    echo "Fetching maintainer tools..."
+    git clone "https://github.com/rust-bitcoin/rust-bitcoin-maintainer-tools.git" ".maintainer-tools"
+    cd ".maintainer-tools"
+    git checkout "$MAINTAINER_TOOLS_REF"
+else
+    cd ".maintainer-tools"
+    CURRENT_REF=$(git rev-parse HEAD)
+    if [ "$CURRENT_REF" != "$MAINTAINER_TOOLS_REF" ]; then
+        echo "Updating maintainer tools to $MAINTAINER_TOOLS_REF"
+        git fetch
+        git checkout "$MAINTAINER_TOOLS_REF"
+    fi
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+    echo "Error: jq is required for maintainer tools but not found in PATH" >&2
+    echo "Please install jq or ensure it's available in your environment" >&2
+    exit 1
+fi
diff --git a/contrib/gen-dep-tree.sh b/contrib/gen-dep-tree.sh
new file mode 100755
index 0000000000..e50b87a0b7
--- /dev/null
+++ b/contrib/gen-dep-tree.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# 
+# Generate dependency tree for all workspace packages except fuzz.
+set -euo pipefail
+
+exec cargo tree \
+    --workspace \
+    --exclude bitcoin-fuzz \
+    --all-features \
+    --edges=no-dev,no-build \
+    --format='{lib}' \
+    --no-dedupe \
+    --prune=serde_json \
+    --prune=rand \
+    --prune=bincode \
+    --prune=serde
diff --git a/contrib/generate-bitcoin-re-export-test.sh b/contrib/generate-bitcoin-re-export-test.sh
new file mode 100755
index 0000000000..1314d93d69
--- /dev/null
+++ b/contrib/generate-bitcoin-re-export-test.sh
@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+#
+# Script for generating a Rust test file that verifies all bitcoin_primitives
+# items are re-exported in the `bitcoin` crate.
+#
+# The script parses api/primitives/all-features.txt and generates use statements
+# that will fail to compile if any re-exports are missing.
+
+set -euo pipefail
+
+api_file="./api/primitives/all-features.txt"
+output_file="./bitcoin/tests/check-re-exports.rs"
+
+usage() {
+    cat <<EOF
+Usage:
+
+    ./generate-bitcoin-re-export-test.sh
+
+DESCRIPTION
+  Generates a Rust test file that verifies all public types and modules from
+  bitcoin_primitives are re-exported in the bitcoin crate;
+
+  The script parses api/primitives/all-features.txt and creates use statements for
+  every 'pub enum', 'pub struct', and 'pub mod' declaration.
+
+  Output file: bitcoin/tests/check-re-exports.rs
+EOF
+}
+
+main() {
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            -h|--help)
+                usage
+                exit 0
+                ;;
+            *)
+                say_err "unknown option: $1"
+                usage
+                exit 1
+                ;;
+        esac
+    done
+
+    check_required_commands
+    check_required_files
+
+    say "Parsing $api_file and generating Rust test..."
+
+    generate_test_file
+
+    say "Generated $output_file"
+    say "Run 'cd bitcoin && cargo test --all-features check_all_bitcoin_primitives_items_are_reexported' to test"
+}
+
+generate_test_file() {
+    local temp_file;
+    temp_file=$(mktemp)
+
+    # Generate the file header
+    cat > "$temp_file" <<'EOF'
+// SPDX-License-Identifier: CC0-1.0
+
+//! Test that all public types and modules from bitcoin_primitives are re-exported in the bitcoin crate.
+//!
+//! This test is automatically generated by contrib/generate-bitcoin-re-export-test.sh
+//! Any compilation error indicates a missing re-export.
+
+#![allow(dead_code)]
+#![allow(unused_imports)]
+// No benefit in running this test without features enabled.
+#[cfg(not(feature = "arbitrary"))]
+compile_error!("arbitrary feature needs to be enabled");
+
+#[test]
+fn check_all_bitcoin_primitives_items_are_reexported() {
+    // This test will fail to compile if any bitcoin_primitives item is not re-exported in the bitcoin crate.
+
+EOF
+
+    # Extract and convert all pub items
+    local use_statements=()
+    local seen_items=()
+
+    while IFS= read -r line; do
+        local path=""
+
+        # Extract pub enum
+        if [[ "$line" =~ pub\ enum\ (bitcoin_primitives::[^[:space:]]+) ]]; then
+            path="${BASH_REMATCH[1]}"
+        # Extract pub struct
+        elif [[ "$line" =~ pub\ struct\ (bitcoin_primitives::[^[:space:]\(]+) ]]; then
+            path="${BASH_REMATCH[1]}"
+        # Extract pub mod
+        elif [[ "$line" =~ ^pub\ mod\ (bitcoin_primitives::[^[:space:]]+)$ ]]; then
+            path="${BASH_REMATCH[1]}"
+        fi
+
+        if [[ -n "$path" ]]; then
+            # Remove generic type parameters (e.g., <T>)
+            path="${path%%<*}"
+
+            if [[ "$path" == *Encoder* ]] || [[ $path == *Decoder* ]]; then
+                continue
+            fi
+
+            # Convert bitcoin_primitives:: to bitcoin::
+            local bitcoin_path="${path//bitcoin_primitives::/bitcoin::}"
+
+            # Skip if we've already seen this item
+            if [[ " ${seen_items[*]} " != *" $bitcoin_path "* ]]; then
+                seen_items+=("$bitcoin_path")
+                use_statements+=("    use $bitcoin_path as _;")
+            fi
+        fi
+    done < "$api_file"
+
+    # Sort use statements and add to file
+    printf '%s\n' "${use_statements[@]}" | sort >> "$temp_file"
+
+    # Add closing brace
+    echo "}" >> "$temp_file"
+
+    # Move temp file to final location
+    mv "$temp_file" "$output_file"
+}
+
+check_required_files() {
+    if [[ ! -f "$api_file" ]]; then
+        err "Required file not found: $api_file"
+    fi
+
+    local output_dir
+    output_dir=$(dirname "$output_file")
+    if [[ ! -d "$output_dir" ]]; then
+        err "Output directory not found: $output_dir"
+    fi
+}
+
+check_required_commands() {
+    need_cmd grep
+    need_cmd sort
+    need_cmd mktemp
+}
+
+say() {
+    echo "generate-bitcoin-re-export-test: $1"
+}
+
+say_err() {
+    say "$1" >&2
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+need_cmd() {
+    if ! command -v "$1" > /dev/null 2>&1
+    then err "need '$1' (command not found)"
+    fi
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/contrib/generate-primitives-re-export-test.sh b/contrib/generate-primitives-re-export-test.sh
new file mode 100755
index 0000000000..ca138eadf3
--- /dev/null
+++ b/contrib/generate-primitives-re-export-test.sh
@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+#
+# Script for generating a Rust test file that verifies all bitcoin_units items
+# are re-exported in bitcoin_primitives.
+#
+# The script parses api/units/all-features.txt and generates use statements
+# that will fail to compile if any re-exports are missing.
+
+set -euo pipefail
+
+api_file="./api/units/all-features.txt"
+output_file="./primitives/tests/check-re-exports.rs"
+
+usage() {
+    cat <<EOF
+Usage:
+
+    ./generate-primitives-re-export-test.sh
+
+DESCRIPTION
+  Generates a Rust test file that verifies all public types and modules from
+  bitcoin_units are re-exported in bitcoin_primitives.
+
+  The script parses api/units/all-features.txt and creates use statements for
+  every 'pub enum', 'pub struct', and 'pub mod' declaration.
+
+  Output file: primitives/tests/check-re-exports.rs
+EOF
+}
+
+main() {
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            -h|--help)
+                usage
+                exit 0
+                ;;
+            *)
+                say_err "unknown option: $1"
+                usage
+                exit 1
+                ;;
+        esac
+    done
+
+    check_required_commands
+    check_required_files
+
+    say "Parsing $api_file and generating Rust test..."
+
+    generate_test_file
+
+    say "Generated $output_file"
+    say "Run 'cd primitives && cargo test --all-features check_all_bitcoin_units_items_are_reexported' to test"
+}
+
+generate_test_file() {
+    local temp_file;
+    temp_file=$(mktemp)
+
+    # Generate the file header
+    cat > "$temp_file" <<'EOF'
+// SPDX-License-Identifier: CC0-1.0
+
+//! Test that all public types and modules from bitcoin_units are re-exported in bitcoin_primitives.
+//!
+//! This test is automatically generated by contrib/generate-primitives-re-export-test.sh
+//! Any compilation error indicates a missing re-export.
+
+#![allow(dead_code)]
+#![allow(unused_imports)]
+// No benefit in running this test without features enabled.
+#[cfg(not(feature = "alloc"))]
+compile_error!("alloc feature needs to be enabled");
+#[cfg(not(feature = "hex"))]
+compile_error!("hex feature needs to be enabled");
+#[cfg(not(feature = "arbitrary"))]
+compile_error!("arbitrary feature needs to be enabled");
+
+#[test]
+fn check_all_bitcoin_units_items_are_reexported() {
+    // This test will fail to compile if any bitcoin_units item is not re-exported in bitcoin_primitives
+
+EOF
+
+    # Extract and convert all pub items
+    local use_statements=()
+    local seen_items=()
+
+    while IFS= read -r line; do
+        local path=""
+
+        # Extract pub enum
+        if [[ "$line" =~ pub\ enum\ (bitcoin_units::[^[:space:]]+) ]]; then
+            path="${BASH_REMATCH[1]}"
+        # Extract pub struct
+        elif [[ "$line" =~ pub\ struct\ (bitcoin_units::[^[:space:]\(]+) ]]; then
+            path="${BASH_REMATCH[1]}"
+        # Extract pub mod
+        elif [[ "$line" =~ ^pub\ mod\ (bitcoin_units::[^[:space:]]+)$ ]]; then
+            path="${BASH_REMATCH[1]}"
+        fi
+
+        if [[ -n "$path" ]]; then
+            # Remove generic type parameters (e.g., <T>)
+            path="${path%%<*}"
+
+            # Convert bitcoin_units:: to bitcoin_primitives::
+            local primitives_path="${path//bitcoin_units::/bitcoin_primitives::}"
+
+            # Skip if we've already seen this item
+            if [[ " ${seen_items[*]} " != *" $primitives_path "* ]]; then
+                seen_items+=("$primitives_path")
+                use_statements+=("    use $primitives_path as _;")
+            fi
+        fi
+    done < "$api_file"
+
+    # Sort use statements and add to file
+    printf '%s\n' "${use_statements[@]}" | sort >> "$temp_file"
+
+    # Add closing brace
+    echo "}" >> "$temp_file"
+
+    # Move temp file to final location
+    mv "$temp_file" "$output_file"
+}
+
+check_required_files() {
+    if [[ ! -f "$api_file" ]]; then
+        err "Required file not found: $api_file"
+    fi
+
+    local output_dir
+    output_dir=$(dirname "$output_file")
+    if [[ ! -d "$output_dir" ]]; then
+        err "Output directory not found: $output_dir"
+    fi
+}
+
+check_required_commands() {
+    need_cmd grep
+    need_cmd sort
+    need_cmd mktemp
+}
+
+say() {
+    echo "generate-primitives-re-export-test: $1"
+}
+
+say_err() {
+    say "$1" >&2
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+need_cmd() {
+    if ! command -v "$1" > /dev/null 2>&1
+    then err "need '$1' (command not found)"
+    fi
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/contrib/release.sh b/contrib/release.sh
index c02657948d..73abdd01f9 100755
--- a/contrib/release.sh
+++ b/contrib/release.sh
@@ -2,33 +2,48 @@
 #
 # Check that we can publish crates in their current form if there are changes on top of the tip of
 # master that imply that we are about to do a release.
+#
+# disable follow sourced files.
+# shellcheck disable=SC1091
 
 set -euox pipefail
 
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# Sets CRATES to be a list of all crates in the repo.
+. "$REPO_DIR"/contrib/test_vars.sh
+
 main () {
-    for crate in "bitcoin" "hashes" "internals" "units"; do
-        if release_changes $crate; then
+    for crate in $CRATES; do
+        if release_changes "$crate"; then
             echo "$crate has changes implying this is a release PR, checking if we can publish ..."
 
             # Check if there is any mention of TBD which means the
             # next version number should be filled in.
-            if grep -qr "since = \"TBD" ./$crate; then
+            if grep -qr "since = \"TBD" "./$crate"; then
                 echo Version number needs to be filled in following places:
-                grep -r "since = \"TBD" ./$crate
+                grep -r "since = \"TBD" "./$crate"
                 exit 1
             fi
 
             # Then try to dry-run cargo publish
-            publish_dry_run $crate
+            publish_dry_run "$crate"
         fi
     done
 }
 
 # Returns 0 if crate ($1) contains changes since tip of master that imply this patch set is done in
 # preparation for releasing the crate.
+
 release_changes() {
     local crate=$1
-    git log --patch --reverse master.. -- "$crate"/Cargo.toml | grep version
+    set +e
+
+    git log --patch --reverse master.. -- "$crate"/Cargo.toml | grep -E '\+version ='
+    local exit_code=$?
+
+    set -e
+    return $exit_code
 }
 
 # Do a dry run publish to crates.io using the correct package name for crate ($1).
diff --git a/contrib/update-lock-files.sh b/contrib/update-lock-files.sh
index 90b1865068..6d73aae93f 100755
--- a/contrib/update-lock-files.sh
+++ b/contrib/update-lock-files.sh
@@ -1,11 +1,30 @@
 #!/usr/bin/env bash
 #
-# Update the minimal/recent lock file
+# Update the minimal and recent lock files.
 
 set -euo pipefail
 
-for file in Cargo-minimal.lock Cargo-recent.lock; do
-    cp -f "$file" Cargo.lock
-    cargo check
-    cp -f Cargo.lock "$file"
-done
+NIGHTLY=$(cat nightly-version)
+
+# The `direct-minimal-versions` and `minimal-versions` dependency
+# resolution strategy flags each have a little quirk. `direct-minimal-versions`
+# allows transitive versions to upgrade, so we are not testing against
+# the actual minimum tree. `minimal-versions` allows the direct dependency
+# versions to resolve upward due to transitive requirements, so we are
+# not testing the manifest's versions. Combo'd together though, we
+# can get the best of both worlds to ensure the actual minimum dependencies
+# listed in the crate manifests build.
+
+# Check that all explicit direct dependency versions are not lying,
+# as in, they are not being bumped up by transitive dependency constraints.
+rm -f Cargo.lock && cargo +"$NIGHTLY" check --all-features -Z direct-minimal-versions
+# Now that our own direct dependency versions can be trusted, check
+# against the lowest versions of the dependency tree which still
+# satisfy constraints. Use this as the minimal version lock file.
+rm -f Cargo.lock && cargo +"$NIGHTLY" check --all-features -Z minimal-versions
+cp -f Cargo.lock Cargo-minimal.lock
+
+# Conservatively bump of recent dependencies.
+cp -f Cargo-recent.lock Cargo.lock
+cargo check --all-features
+cp -f Cargo.lock Cargo-recent.lock
diff --git a/bitcoin/contrib/whitelist_deps.sh b/contrib/whitelist_deps.sh
similarity index 53%
rename from bitcoin/contrib/whitelist_deps.sh
rename to contrib/whitelist_deps.sh
index 42cc286e8b..cb4a22b130 100644
--- a/bitcoin/contrib/whitelist_deps.sh
+++ b/contrib/whitelist_deps.sh
@@ -4,4 +4,7 @@
 # disable verify unused vars, despite the fact that they are used when sourced
 # shellcheck disable=SC2034
 
-DUPLICATE_DEPS=("hashes")
+# - hashes because of secp v0.30
+# - io because of hashes
+# - hex because 1.0 only has decoding
+DUPLICATE_DEPS=("bitcoin_hashes" "hex-conservative" "bitcoin-io")
diff --git a/crypto/CHANGELOG.md b/crypto/CHANGELOG.md
new file mode 100644
index 0000000000..4ac809f05a
--- /dev/null
+++ b/crypto/CHANGELOG.md
@@ -0,0 +1,3 @@
+# 0.0.0 - Initial dummy release
+
+- Empty crate to reserve the name on crates.io
diff --git a/crypto/Cargo.toml b/crypto/Cargo.toml
new file mode 100644
index 0000000000..548c9b9936
--- /dev/null
+++ b/crypto/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "bitcoin-crypto"
+version = "0.0.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+license = "CC0-1.0"
+repository = "https://github.com/rust-bitcoin/rust-bitcoin"
+description = "Crypto support for the rust-bitcoin ecosystem"
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["bitcoin", "types"]
+readme = "README.md"
+edition = "2021"
+rust-version = "1.74.0"
+exclude = ["tests", "contrib"]
+
+[features]
+default = ["std"]
+std = ["alloc"]
+alloc = []
+
+[dependencies]
+
+[dev-dependencies]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/crypto/README.md b/crypto/README.md
new file mode 100644
index 0000000000..f1e74122a8
--- /dev/null
+++ b/crypto/README.md
@@ -0,0 +1,3 @@
+# Cryptography
+
+Types and logic required to support cryptography i.e., bitcoin keys.
diff --git a/crypto/contrib/extra_lints.sh b/crypto/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/crypto/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/crypto/contrib/test_vars.sh b/crypto/contrib/test_vars.sh
new file mode 100644
index 0000000000..92dc094064
--- /dev/null
+++ b/crypto/contrib/test_vars.sh
@@ -0,0 +1,14 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+#
+# disable verify unused vars, despite the fact that they are used when sourced
+# shellcheck disable=SC2034
+
+# Test all these features with "std" enabled.
+FEATURES_WITH_STD=""
+
+# Test all these features without "std" enabled.
+FEATURES_WITHOUT_STD="alloc"
+
+# Run these examples.
+EXAMPLES=""
diff --git a/crypto/src/lib.rs b/crypto/src/lib.rs
new file mode 100644
index 0000000000..0d98f783a6
--- /dev/null
+++ b/crypto/src/lib.rs
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Cryptography support for the rust-bitcoin ecosystem.
+
+// NB: This crate is empty if `alloc` is not enabled.
+#![cfg(feature = "alloc")]
+#![no_std]
+// Experimental features we need.
+#![doc(test(attr(warn(unused))))]
+// Coding conventions.
+#![warn(deprecated_in_future)]
+#![warn(missing_docs)]
+// Exclude lints we don't think are valuable.
+#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+#![allow(clippy::manual_range_contains)] // More readable than clippy's format.
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000000..9d90c1bc75
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,13 @@
+# rust-bitcoin documentation
+
+This directory holds documentation for the `rust-bitcoin` repository and potentially various other
+directly related crates from the `rust-bitcoin` GitHub organisation (e.g. `rust-secp256k1`).
+
+In general, PR discussions on source code should be about the technical content of changes. To debate
+whether a change should be made at all, or the strategy for making changes, it is better to first PR to
+the `docs/` tree. If a PR discussion veers into this sort of strategic discussion, the PR should be put on
+hold and a PR made to the `docs/` tree or in the Discussions section to debate it before moving forward.
+
+## Dependency tree
+
+The `./dep-tree` file was generated using `just gen-dep-tree`.
diff --git a/docs/addresses.md b/docs/addresses.md
new file mode 100644
index 0000000000..f55b57989d
--- /dev/null
+++ b/docs/addresses.md
@@ -0,0 +1,3 @@
+# Split out an address crate
+
+Split the `address` module out into its own crate.
diff --git a/docs/adr/0001_consensus_encoding.md b/docs/adr/0001_consensus_encoding.md
new file mode 100644
index 0000000000..48bb1553a9
--- /dev/null
+++ b/docs/adr/0001_consensus_encoding.md
@@ -0,0 +1,151 @@
+# consensus_encoding crate for sans-I/O
+
+* Status: accepted
+* Authors: Andrew Poelstra
+* Date: 2025-09-06
+* Targeted modules: `consensus_encoding`, `primitives`, `units`
+* Associated tickets/PRs: #4912
+
+## Context and Problem Statement
+
+The rust-bitcoin project needs a way to perform consensus encoding/decoding operations without depending on std. The existing consensus encoding approach is somewhat tied to the `std::io` interfaces, but in order to make it no-std compatible, the `bitcoin-io` crate was introduced with "bridges" to the std I/O traits. But despite the best efforts of the bridges, there is still a lot of caller friction. Plus there is a requirement to always deal with I/O errors even in non-I/O contexts (e.g. hashing an encoding).
+
+Is there a way to better support encoding in no-std, std, non-I/O, and even async contexts?
+
+## Decision Drivers
+
+* Support no_std environments.
+* Reduce API friction.
+* Eliminate I/O errors in non-I/O contexts.
+
+## Considered Options
+
+#### Option 1: Roll with the existing bitcoin-io crate
+
+The crate has its pain points, but it gets the job done.
+
+**Pros:**
+
+* Maintains existing API surface.
+
+**Cons:**
+
+* Pain points for the general `std::io` case and error handling remain.
+* The interface would be tied to the v1.0.0 release of the `primitives` and `units` crates, requiring maintenance support for a very long time.
+
+#### Option 2: Adopt the push_decode crate
+
+Martin Habovštiak wrote a general purpose sans-I/O encoding/decoding crate, [`push_decode`], which satisfies the technical requirements.
+
+**Pros:**
+
+* Already written.
+* Removes ties to std I/O and I/O errors.
+
+**Cons:**
+
+* Is general purpose, so has a few layers of abstraction and complexity not required in the bitcoin domain.
+
+#### Option 3: Create dedicated consensus_encoding crate
+
+Extract consensus encoding/decoding logic into a new crate which is sans-I/O and focused only on the bitcoin domain.
+
+**Pros:**
+
+* Removes ties to std I/O and I/O errors.
+* Interface is tailored for the bitcoin domain.
+
+**Cons:**
+
+* Requires most amount of new code to write and maintain.
+
+## Decision Outcome
+
+Option #3, dedicated `consensus_encoding` crate. While it is new code, it is heavily based on [`push_decode`] and slimmed down to just what is required in the workspace. It supports no-std, std, non-I/O, and could support async contexts. It should be relatively cheap to maintain given the limited domain.
+
+## Technical Design
+
+The `consensus_encoding` crate provides traits and utilities for encoding and decoding Bitcoin data types in a consensus-consistent way. This crate implements a **sans-I/O** architecture, designed to work efficiently in `no_std` environments while supporting both synchronous and asynchronous I/O when needed.
+
+The implementation is heavily based on the more general [`push_decode`] crate written by Martin Habovštiak. But where `push_decode` is flexible to handle many different encoding scenarios, `consensus_encoding` has been slimmed down to only handle what is required by the Bitcoin ecosystem.
+
+Sans-I/O architecture separates data codecs from I/O operations. Instead of reading directly from `io::Read` traits or writing to `io::Write` traits, the core types work with byte slices and provide iterator-like interfaces for consuming data. Same codec logic works for sync I/O, async I/O, or other use cases such as hash engines. So unlike traditional "pull decoders" that read data on-demand, this crate uses a "push" approach where *decoders* consume data in chunks and maintain internal state. The *caller* drives the process by managing buffers and I/O to push bytes into the decoder. And on the other side, *encoders* produce data in chunks which a caller pulls in order to write to a sink.
+
+Encoding is generally infallible (e.g. encoding to `Vec` never fails). Decoding on the other hand has to deal with many failure scenarios due to not owning the bytes it's consuming. This complicates the interface as decoders provide specific errors for failure modes (`UnexpectedEof`, `InvalidData`, etc.). But I/O errors are handled by the caller functions, keeping the core codec logic I/O-agnostic.
+
+### Encoders
+
+```rust
+pub trait Encodable {
+    type Encoder<'s>: Encoder
+    where
+        Self: 's;
+
+    fn encoder(&self) -> Self::Encoder<'_>;
+}
+
+pub trait Encoder {
+    fn current_chunk(&self) -> &[u8];
+    fn advance(&mut self) -> bool;
+}
+```
+
+A Bitcoin type implements `Encodable` in order to produce `Encoder` instances for its type. So for example a `Transaction` type is made `Encodable` and linked to a `TransactionEncoder` type which implements `Encoder`. The `Encodable` trait makes use of Rust's [Generic Associated Type (GAT)] feature which ties `Encoder` lifetimes to the instance of the type they are encoding. This allows the encoder to avoid any copy or clones of bytes, instead referencing them directly, which is often powerful in the Bitcoin context where bytes are already in encoded form.
+
+Once a caller has an `Encoder` instance, it pulls bytes out with calls to `Encoder::current_chunk`. The caller bounces between `Encoder::current_chunk` and `Encoder::advance` until the encoder is exhausted which is signaled by `Encoder::advance` returning `false`. While we considered making these a single method, the "immutable accessor method plus mutable advance state method" greatly simplifies lifetime management when encoders are combined. And encoder composition is very common in Bitcoin types which are generally composed internally of other Bitcoin types. 
+
+### Decoders
+
+```rust
+pub trait Decodable {
+    type Decoder: Decoder<Output = Self>;
+    fn decoder() -> Self::Decoder;
+}
+
+pub trait Decoder: Sized {
+    type Output;
+    type Error;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error>;
+    fn end(self) -> Result<Self::Output, Self::Error>;
+    fn read_limit(&self) -> usize;
+}
+```
+
+Similar to encoding, Bitcoin types implement `Decodable` in order to generate `Decoder`s. Unlike encoding, no GAT is required since the decoder is taking ownership of the bytes.
+
+The caller interface is significantly more complex than encoding since `Decoder`s are fallible, so both `Decoder::push_bytes` and `Decoder::end` return a `Result`. A caller pushes bytes through `Decoder::push_bytes` until it returns `false`. That is the signal for the caller to now consume the `Decoder` with `Decoder::end` and get the output type. The `bytes` parameter of `Decoder::push_bytes` is mutable to allow the decoder to "consume" bytes by advancing the slice. Any un-used bytes remain in the `bytes` buffer.
+
+The `Decoder::read_limit` method has no encoding parallel. It is another complexity due to decoders not having a priori knowledge about the amount of bytes they will be dealing with. But this helper function supplies hints to callers which allows them to better manage their buffer for the decoder, avoiding both inefficient under-reads and unnecessary over-reads.
+
+### Callers
+
+Library consumers can always define callers for their specific needs (e.g. async), but callers for the most common use cases are provided by the crate as free functions. Here are the signatures of the provided callers which obviously connect codecs to the standard library I/O.
+
+```rust
+#[cfg(feature = "std")]
+pub fn encode_to_writer<T, W>(object: &T, mut writer: W) -> Result<(), std::io::Error>
+where
+    T: Encodable + ?Sized,
+    W: std::io::Write,
+{}
+
+#[cfg(feature = "std")]
+pub fn decode_from_read<T, R>(mut reader: R) -> Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: std::io::BufRead,
+{}
+```
+
+The keen eye will catch how the decode caller requires the use of a `std::io::BufRead` instead of just `std::io::Read`. While the crate also supports `std::io::Read`, `std::io::BufRead` mitigates a lot of the complexity for decoder buffer management and will almost always be more performant.
+
+## Links
+
+* Initial implementation in [#4912].
+* First release in [#5160].
+
+[#4912]: <https://github.com/rust-bitcoin/rust-bitcoin/pull/4912>
+[#5160]: <https://github.com/rust-bitcoin/rust-bitcoin/pull/5160>
+[`push_decode`]: <https://github.com/Kixunil/push_decode>
+[Generic Associated Type (GAT)]: <https://blog.rust-lang.org/2022/10/28/gats-stabilization/>
diff --git a/docs/adr/template.md b/docs/adr/template.md
new file mode 100644
index 0000000000..e17f979427
--- /dev/null
+++ b/docs/adr/template.md
@@ -0,0 +1,56 @@
+# [short title of solved problem and solution]
+
+* Status: [proposed | rejected | accepted | deprecated | … | superseded by ADR-1234]
+* Authors: [list everyone who authored the decision]
+* Date: [YYYY-MM-DD when the decision was last updated]
+* Targeted modules: [which crate or module does this change target]
+* Associated tickets/PRs: [PR/issue links]
+
+## Context and Problem Statement
+
+[Describe the context and problem statement, e.g., in free form using two to three sentences. You may want to articulate the problem in form of a question.]
+
+## Decision Drivers <!-- optional -->
+
+* [driver 1, e.g., a force, facing concern, …]
+* [driver 2, e.g., a force, facing concern, …]
+* … <!-- numbers of drivers can vary -->
+
+## Considered Options <!-- numbers of options can vary -->
+
+#### [Option 1]
+
+[example | description | pointer to more information | …]
+
+**Pros:**
+
+* Good, because [argument …]
+
+**Cons:**
+
+* Bad, because [argument …]
+
+#### [Option 2]
+...
+
+#### [Option 3]
+...
+
+## Decision Outcome
+
+Chosen option: "[option 1]", because [justification. e.g., only option, which meets k.o. criterion decision driver | which resolves force force | … | comes out best (see below)].
+
+### Positive Consequences <!-- optional -->
+
+* [e.g., improvement of quality attribute satisfaction, follow-up decisions required, …]
+* …
+
+### Negative Consequences <!-- optional -->
+
+* [e.g., compromising quality attribute, follow-up decisions required, …]
+* …
+
+## Links <!-- optional -->
+
+* [Link type] [Link to ADR] <!-- example: Refined by [ADR-0005](0005-example.md) -->
+* … <!-- numbers of links can vary -->
diff --git a/docs/bip-32.md b/docs/bip-32.md
new file mode 100644
index 0000000000..8f6f501af0
--- /dev/null
+++ b/docs/bip-32.md
@@ -0,0 +1,19 @@
+# BIP-0032 and BIP-0380
+
+The current module has not been patched much in the last 5 years and the rest of the code base has
+stylistically changed quite a bit.
+
+* Re-write the BIP-0032 API
+* Add support for BIP-0380
+
+See [BIP-0032 super issue](https://github.com/rust-bitcoin/rust-bitcoin/issues/4770).
+
+
+## Notes
+
+If you see some design issue missing, feel free to PR to update this file, or to post to the super
+issue for discussion. But don't assume that we will be able to find anything in the super issue
+later [0] ; anything actionable that comes out of the super issue should be posted to this doc for
+posterity.
+
+- [0] GitHub issues are notoriously difficult to read when they get a lot of discussion.
diff --git a/docs/crates.md b/docs/crates.md
new file mode 100644
index 0000000000..628a2e0d31
--- /dev/null
+++ b/docs/crates.md
@@ -0,0 +1,48 @@
+# rust-bitcoin stack of crates
+
+The `rust-bitcoin` project is in the, very long, process of crate
+smashing. The original single `rust-bitcoin` crate has already been
+broken into a number of pieces and this work is ongoing. Both current
+and future crates are documented here. Future crates typically have an
+entry in [roadmap.md] and likely also a file of their own.
+
+## Current crates
+
+- `addresses`: **Empty** placeholder (see future crates below).
+- `base58`: Bitcoin base58 encoding and decoding (for pre-segwit addresses).
+- `bitcoin`: The `rust-bitcoin` crate.
+- `chacha20_poly1305`: ChaCha20 stream cipher with the Poly1305 MAC.
+- `consensus_encoding`: Consensus encoding and decoding.
+- `crypto`: Cryptography support for the rust-bitcoin ecosystem.
+- `hashes`: Rust Bitcoin hashes library.
+- `internals`: Used internally by crates in this repo.
+- `io`: Rust Bitcoin I/O library (to support `no_std`).
+- `p2p`: Rust Bitcoin peer to peer message types.
+- `primitives`: Rust Bitcoin primitive types.
+- `units`: Rust Bitcoin unit types.
+
+### Crates in our stack but in different repositories
+
+A few crates are in different repositories, primarily because they were either started by different
+people or they have a (slightly) different set of maintainers and/or merge policy.
+
+- `secp256k1`: https://github.com/rust-bitcoin/rust-secp256k1
+- `bech32`: https://github.com/rust-bitcoin/rust-bech32
+- `hex-conservative`: https://github.com/rust-bitcoin/hex-conservative
+- `miniscript`: https://github.com/rust-bitcoin/rust-miniscript
+
+## Future crates
+
+- `addresses`: Bitcoin addresses (see [addresses.md])
+- `bip-32`: BIP-0032 (and maybe BIP-0380) support (see [bip-32.md])
+- `psbt`: PSBTv2 support (see [psbt.md])
+- `keys`/`crypto`: Cryptography stuff or maybe just keys (see [keys.md])
+
+## Re-export policy
+
+See `./policy.md`.
+
+[addresses.md]: ./addresses.md
+[bip-32.md]: ./bip-32.md
+[keys.md]: ./keys.md
+[psbt.md]: ./psbt.md
diff --git a/docs/crypto.md b/docs/crypto.md
new file mode 100644
index 0000000000..03f5546568
--- /dev/null
+++ b/docs/crypto.md
@@ -0,0 +1,65 @@
+# Bitcoin keys / Bitcoin crypto
+
+Either `bitcoin-keys` and just have keys in it or `bitcoin-crypto` and
+have the other stuff from `bitcoin::crypto` in it.
+
+## `secp256k1`
+
+Both `bitcoin-keys` and `bitcoin-crypto` would depend on `secp256k1`.
+
+Other things that use secp directly or indirectly through keys/crypto:
+
+- `addresses` (for keys only)
+- `bip-32` (for keys only)
+- `psbt` for keys and signing
+- Taproot script extension methods
+- `bitcoin::taproot` module (uses secp directly)
+- `bitcoin::sign_message` module (uses secp directly)
+
+Taproot stuff is quite entangled in various places throughout the
+codebase which in turn entangles secp.
+
+## Keys
+
+Public and private keys. 
+
+The reason for splitting this out is so that other crates can depend on keys without depending on
+`bitcoin` e.g., `addresses`.
+
+(Note plural for crate name and singular for current module name, in line with what we did for
+`address` module and `addresses` crate.)
+
+Current public types in `bitcoin::crypto::key`:
+
+- `XOnlyPublicKey`
+- `PublicKey`
+- `SortKey`
+- `PubkeyHash`
+- `WPubkeyHash`
+- `CompressedPublicKey`
+- `PrivateKey`
+- `TweakedPublicKey`
+- `TweakedKeypair`
+- `SerializedXOnlyPublicKey`
+- Various error types
+- `TapTweak` trait
+
+### Current obvious complications
+
+Looking at `bitcoin::crypto::key` there are some obvious things that will need fixing.
+
+#### `NetworkKind`
+
+Currently we are using `bitcoin::network::NetworkKind` in `PrivateKey`.
+
+- Used to get the first byte of WIF format
+- Passed to functions that create addresses e.g., `Address::p2pkh(key, network)`
+
+#### `ScriptBuf`
+
+Possibly ok if we have a dependency on `primitives`. Only used for scriptcode.
+
+#### Taproot stuff
+
+`TapNodeHash` and `TapTweakHash` are used to implement the `TapTweak` trait on `UntweakedPublickey`
+and `UntweakedKeypair`.
diff --git a/docs/dep-tree b/docs/dep-tree
new file mode 100644
index 0000000000..7f69bb0f0f
--- /dev/null
+++ b/docs/dep-tree
@@ -0,0 +1,200 @@
+base58ck
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+└── bitcoin_hashes
+    ├── bitcoin_internals
+    │   └── hex_conservative
+    │       └── arrayvec
+    └── hex_conservative
+        └── arrayvec
+
+bitcoin
+├── arbitrary
+├── base58ck
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── bitcoin_hashes
+│       ├── bitcoin_internals
+│       │   └── hex_conservative
+│       │       └── arrayvec
+│       └── hex_conservative
+│           └── arrayvec
+├── base64
+├── bech32
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+├── bitcoin_io
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── bitcoin_hashes
+│       ├── bitcoin_internals
+│       │   └── hex_conservative
+│       │       └── arrayvec
+│       └── hex_conservative
+│           └── arrayvec
+├── bitcoin_primitives
+│   ├── arbitrary
+│   ├── arrayvec
+│   ├── bitcoin_consensus_encoding
+│   │   ├── bitcoin_internals
+│   │   │   └── hex_conservative
+│   │   │       └── arrayvec
+│   │   └── bitcoin_hashes
+│   │       ├── bitcoin_internals
+│   │       │   └── hex_conservative
+│   │       │       └── arrayvec
+│   │       └── hex_conservative
+│   │           └── arrayvec
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   ├── bitcoin_units
+│   │   ├── arbitrary
+│   │   ├── bitcoin_consensus_encoding
+│   │   │   ├── bitcoin_internals
+│   │   │   │   └── hex_conservative
+│   │   │   │       └── arrayvec
+│   │   │   └── bitcoin_hashes
+│   │   │       ├── bitcoin_internals
+│   │   │       │   └── hex_conservative
+│   │   │       │       └── arrayvec
+│   │   │       └── hex_conservative
+│   │   │           └── arrayvec
+│   │   └── bitcoin_internals
+│   │       └── hex_conservative
+│   │           └── arrayvec
+│   ├── bitcoin_hashes
+│   │   ├── bitcoin_internals
+│   │   │   └── hex_conservative
+│   │   │       └── arrayvec
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── hex_conservative
+│       └── arrayvec
+├── bitcoin_units
+│   ├── arbitrary
+│   ├── bitcoin_consensus_encoding
+│   │   ├── bitcoin_internals
+│   │   │   └── hex_conservative
+│   │   │       └── arrayvec
+│   │   └── bitcoin_hashes
+│   │       ├── bitcoin_internals
+│   │       │   └── hex_conservative
+│   │       │       └── arrayvec
+│   │       └── hex_conservative
+│   │           └── arrayvec
+│   └── bitcoin_internals
+│       └── hex_conservative
+│           └── arrayvec
+├── bitcoin_hashes
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── hex_conservative
+│       └── arrayvec
+├── bitcoinconsensus
+├── hex_conservative
+│   └── arrayvec
+└── secp256k1
+    ├── bitcoin_hashes
+    │   ├── bitcoin_io
+    │   └── hex_conservative
+    │       └── arrayvec
+    └── secp256k1_sys
+
+bitcoin_addresses
+
+bitcoin_consensus_encoding
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+└── bitcoin_hashes
+    ├── bitcoin_internals
+    │   └── hex_conservative
+    │       └── arrayvec
+    └── hex_conservative
+        └── arrayvec
+
+bitcoin_internals
+└── hex_conservative
+    └── arrayvec
+
+bitcoin_io
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+└── bitcoin_hashes
+    ├── bitcoin_internals
+    │   └── hex_conservative
+    │       └── arrayvec
+    └── hex_conservative
+        └── arrayvec
+
+bitcoin_primitives
+├── arbitrary
+├── arrayvec
+├── bitcoin_consensus_encoding
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── bitcoin_hashes
+│       ├── bitcoin_internals
+│       │   └── hex_conservative
+│       │       └── arrayvec
+│       └── hex_conservative
+│           └── arrayvec
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+├── bitcoin_units
+│   ├── arbitrary
+│   ├── bitcoin_consensus_encoding
+│   │   ├── bitcoin_internals
+│   │   │   └── hex_conservative
+│   │   │       └── arrayvec
+│   │   └── bitcoin_hashes
+│   │       ├── bitcoin_internals
+│   │       │   └── hex_conservative
+│   │       │       └── arrayvec
+│   │       └── hex_conservative
+│   │           └── arrayvec
+│   └── bitcoin_internals
+│       └── hex_conservative
+│           └── arrayvec
+├── bitcoin_hashes
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── hex_conservative
+│       └── arrayvec
+└── hex_conservative
+    └── arrayvec
+
+bitcoin_units
+├── arbitrary
+├── bitcoin_consensus_encoding
+│   ├── bitcoin_internals
+│   │   └── hex_conservative
+│   │       └── arrayvec
+│   └── bitcoin_hashes
+│       ├── bitcoin_internals
+│       │   └── hex_conservative
+│       │       └── arrayvec
+│       └── hex_conservative
+│           └── arrayvec
+└── bitcoin_internals
+    └── hex_conservative
+        └── arrayvec
+
+bitcoin_hashes
+├── bitcoin_internals
+│   └── hex_conservative
+│       └── arrayvec
+└── hex_conservative
+    └── arrayvec
+
+chacha20_poly1305
diff --git a/docs/dependencies.md b/docs/dependencies.md
new file mode 100644
index 0000000000..113dbb2307
--- /dev/null
+++ b/docs/dependencies.md
@@ -0,0 +1,39 @@
+# Policy on adding dependencies 
+
+TL;DR We are averse to adding dependencies, there needs to be a strong case for it.
+
+Applies to any crate in the `rust-bitcoin` repository. When adding functionality one can add a
+dependency or NIH it. When evaluating a dependency we consider:
+
+* Maintainers are reputable and know idiomatic Rust well-enough
+* Maintainers respond to bug reports quickly
+* Idiomatic API, well documented, ideally stable or close to stable
+* Conservative MSRV - hard requirement for mandatory dependencies
+* Reasonable performance
+* Good test coverage, CI, fuzzing, clippy, miri (if applicable)
+* No reckless `unsafe` (see below).
+* Maintainer responds well to code quality PRs (refactors)
+
+These requirements apply recursively and the total dependency tree must not contain significantly
+more code than what is required to implement the desired feature.
+
+### Reckless unsafe 
+
+Reckless `unsafe` is defined as having any of these properties: 
+
+- Large complicated chunks of `unsafe` (whole module containing `unsafe` is an `unsafe` chunk!).
+- (private) function not marked `unsafe` when it can UB depending on arguments (`actix-web` flamewar).
+- Code that can be written without `unsafe` while staying equally fast thanks to compiler optimizations.
+- Missing safe abstractions.
+
+### What this means
+
+In practice, any dependencies that fail the above sanity checks are rejected out of hand. 
+
+After that, discussion becomes about these more nuanced topics:
+
+* Whether the benefit is too niche/special-case.
+* Possible past MSRV disagreements with the maintainers.
+* Where we have our own unsafe code and wonder whether we should outsource the responsibility or not
+  (e.g. `ArrayVec`) 
+
diff --git a/docs/keys.md b/docs/keys.md
new file mode 100644
index 0000000000..7c1401cdb4
--- /dev/null
+++ b/docs/keys.md
@@ -0,0 +1,64 @@
+# Bitcoin keys / Bitcoin crypto
+
+Either `bitcoin-keys` and just have keys in it or `bitcoin-crypto` and
+have the other stuff from `bitcoin::crypto` in it.
+
+For now we use term 'keys', above is an open question.
+
+## On `secp256k1`
+
+Both `bitcoin-keys` and `bitcoin-crypto` would depend on `secp256k1`.
+
+Other things that use secp directly or indirectly through keys/crypto:
+
+- `addresses` (for keys only)
+- `bip-32` (for keys only)
+- `psbt` for keys and signing
+- Taproot script extension methods
+- `bitcoin::taproot` module (uses secp directly)
+- `bitcoin::sign_message` module (uses secp directly)
+
+## Related to keys
+
+Public and private keys. 
+
+The reason for splitting this out is so that other crates can depend on keys without depending on
+`bitcoin` e.g., `addresses`.
+
+(Note plural for crate name and singular for current module name, in line with what we did for
+`address` module and `addresses` crate.)
+
+Current public types in `bitcoin::crypto::key`:
+
+- `XOnlyPublicKey`
+- `PublicKey`
+- `SortKey`
+- `PubkeyHash`
+- `WPubkeyHash`
+- `CompressedPublicKey`
+- `PrivateKey`
+- `TweakedPublicKey`
+- `TweakedKeypair`
+- `SerializedXOnlyPublicKey`
+- Various error types
+- `TapTweak` trait
+
+### Current obvious complications
+
+Looking at `bitcoin::crypto::key` there are some obvious things that will need fixing.
+
+#### `NetworkKind`
+
+Currently we are using `bitcoin::network::NetworkKind` in `PrivateKey`.
+
+- Used to get the first byte of WIF format
+- Passed to functions that create addresses e.g., `Address::p2pkh(key, network)`
+
+#### `ScriptBuf`
+
+Possibly ok if we have a dependency on `primitives`. Only used for scriptcode.
+
+#### Taproot stuff
+
+`TapNodeHash` and `TapTweakHash` are used to implement the `TapTweak` trait on `UntweakedPublickey`
+and `UntweakedKeypair`.
diff --git a/docs/policy.md b/docs/policy.md
new file mode 100644
index 0000000000..9b6b733234
--- /dev/null
+++ b/docs/policy.md
@@ -0,0 +1,374 @@
+# Coding policy for the rust-bitcoin repository
+
+We have various `rust-bitcoin` specific coding styles and conventions that are
+grouped here loosely under the term 'policy'. These are things we try to adhere
+to but that you should not need to worry too much about if you are a new
+contributor. Think of this as a place to collect group knowledge that exists in
+the various PRs over the last few years.
+
+## Import statements
+
+We use the following style for import statements, see
+(https://github.com/rust-bitcoin/rust-bitcoin/discussions/2088) for the discussion that led to this.
+
+```rust
+// Modules first, as they are part of the project's structure.
+pub mod aa_this;
+mod bb_private;
+pub mod cc_that;
+
+// Private imports, rustfmt will sort and merge them correctly.
+use crate::aa_this::{This, That};
+use crate::bb_that;
+
+// Public re-exports.
+#[rustfmt::skip] // Keeps public re-exports separate, because of this we have to sort manually.
+pub use {
+    crate::aa_aa_this,
+    crate::bb_bb::That,
+}
+
+// Avoid wildcard imports, except for 3 rules:
+
+// Rule 1 - test modules.
+#[cfg(test)]
+mod tests {
+    use super::*; // OK
+}
+
+// Rule 2 - enum variants.
+use LockTime::*; // OK
+
+// Rule 3 - opcodes.
+use opcodes::all::*; // OK
+
+// Finally here is an example where we don't allow wildcard imports:
+use crate::prelude::*; // *NOT* OK
+use crate::prelude::{DisplayHex, String, Vec} // OK
+```
+
+## Re-exports
+
+Types should _not_ be re-exported unless it is _really_ helpful. I.e., we considered re-exporting
+types from modules where they appear in the public API but decided against it.
+
+### pub extern crates
+
+Any crate `foo` which exposes a type from crate `bar` MUST publicly re-export `bar` crate at the
+root.
+
+
+For example:
+
+```rust
+/// Re-export the `hex-conservative` crate.
+pub extern crate hex;
+```
+
+Note, can use this exact doc format.
+
+### Special treatment of `bitcoin`, `primitives`, `units`
+
+`bitcoin`, `primitives`, and `units` should each be a superset of the crates below.
+
+E.g for any `units::Foo`, there will be a `primitives::Foo`, and `bitcoin::Foo`. This goes for all
+types and modules.
+
+For these three crates:
+
+- Non-error re-exports use `doc(inline)`.
+- Error re-exports use `doc(no_inline)`.
+- Error types that are directly in the API are re-exported.
+- Other error types are available in an `error` module.
+
+For example in `units`:
+
+```rust
+
+pub mod foo {
+    // SomeError is 'directly' in the API but FooError is not.
+    pub use self::error::SomeError;
+
+    /// A FooBar type.
+    pub struct FooBar { ... };
+
+    /// Some function.
+    pub fn some_function() -> SomeError {
+        // Example error logic
+        SomeError::Foo(FooError { ... })
+    }
+
+    pub mod error {
+        /// Example error used 'directly' in the public API.
+        pub enum SomeError { ... };
+
+        /// Abstracts the details of a foo-related error.
+        pub struct FooError { ... };
+    }
+}
+```
+
+Then in `primitives` (and in `bitcoin`) in `lib.rs`:
+
+```rust
+#[doc(inline)]
+pub use units::{foo, FooBar};
+#[doc(no_inline)]
+pub use units::foo::SomeError;
+```
+
+### Usage of re-exports
+
+As part of the attempt to mirror the `units` and `primitives`, and `bitcoin` APIs, in this codebase,
+policy is to use types from the highest crate available i.e `use crate::Foo` not `units::Foo`.
+
+This is enforced by CI.
+
+## Return `Self`
+
+Use `Self` as the return type instead of naming the type. When constructing the return value use
+`Self` or the type name, whichever you prefer.
+
+```rust
+/// A counter that is always smaller than 100.
+pub struct Counter(u32);
+
+impl Counter {
+    /// Constructs a new `Counter`.
+    pub fn new() -> Self { Self(0) }
+
+    /// Returns a counter if it is possible to create one from x.
+    pub fn maybe(x: u32) -> Option<Self> {
+        match x {
+            x if x >= 100 => None,
+            c => Some(Counter(c)),
+        }
+    }
+}
+
+impl TryFrom<u32> for Counter {
+    type Error = TooBigError;
+
+    fn try_from(x: u32) -> Result<Self, Self::Error> {
+        if x >= 100 {
+            return Err(TooBigError);
+        }
+        Ok(Counter(x))
+    }
+}
+```
+
+When constructing the return value for error enums use `Self`.
+
+```rust
+impl From<foo::Error> for LongDescriptiveError {
+    fn from(e: foo::Error) -> Self { Self::Foo(e) }
+}
+```
+
+## Errors
+
+Return as much context as possible with errors e.g., if an error was encountered parsing a string
+include the string in the returned error type. If a function consumes costly-to-compute input
+(allocations are also considered costly) it should return the input back in the error type.
+
+More specifically an error should
+
+- be `non_exhaustive` unless we _really_ never want to change it.
+- have private fields unless we are very confident they won't change.
+- derive `Debug, Clone, PartialEq, Eq` (and `Copy` if and only if not `non_exhaustive`).
+- implement Display using `write_err!()` macro if a variant contains an inner error source.
+- have `Error` suffix on error types (structs and enums).
+- not have `Error` suffix on enum variants.
+- call `internals::impl_from_infallible!`.
+- implement `std::error::Error` if they are public (feature gated on "std").
+- have messages in lower case, except for proper nouns and variable names.
+
+```rust
+/// Documentation for the `Error` type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]  // Add liberally; if the error type may ever have new variants added.
+pub enum Error {
+    /// Documentation for variant A.
+    A,
+    /// Documentation for variant B.
+    B,
+}
+
+internals::impl_from_infallible!(Error);
+
+```
+
+All errors that live in an `error` module (eg, `foo/error.rs`) and appear in a public function in
+`foo` module should be available from `foo` i.e., should be re-exported from `foo/mod.rs`.
+
+## `expect` messages
+
+With respect to `expect` messages, they should follow the
+[Rust standard library guidelines](https://doc.rust-lang.org/std/option/enum.Option.html#recommended-message-style).
+More specifically, `expect` messages should be used to describe the reason
+you expect the operation to succeed.
+For example, this `expect` message clearly states why the operation should succeed:
+
+```rust
+/// Serializes the public key to bytes.
+pub fn to_bytes(self) -> Vec<u8> {
+    let mut buf = Vec::new();
+    self.write_into(&mut buf).expect("vecs don't error");
+    buf
+}
+```
+
+Also note that `expect` messages, as with all error messages, should be lower
+case, except for proper nouns and variable names.
+
+<details>
+<summary>The details on why we chose this style</summary>
+
+According to the [Rust standard library](https://doc.rust-lang.org/std/error/index.html#common-message-styles),
+there are two common styles for how to write `expect` messages:
+
+- using the message to present information to users encountering a panic
+  ("expect as error message"); and
+- using the message to present information to developers debugging the panic
+  ("expect as precondition").
+
+We opted to use the "expect as precondition" since it clearly states why the
+operation should succeed.
+This may be better for communicating with developers, since they are the target
+audience for the error message and `rust-bitcoin`.
+
+If you want to know more about the decision error messages and expect messages,
+please check:
+
+- https://github.com/rust-bitcoin/rust-bitcoin/issues/2913
+- https://github.com/rust-bitcoin/rust-bitcoin/issues/3053
+- https://github.com/rust-bitcoin/rust-bitcoin/pull/3019
+</details>
+
+## Rustdocs
+
+Be liberal with references to BIPs or other documentation; the aim is that devs can learn about
+Bitcoin by hacking on this codebase as opposed to having to learn about Bitcoin first and then start
+hacking on this codebase. Consider the following format, not all sections will be required for all types.
+
+
+```rust
+/// The Bitcoin foobar.
+///
+/// Contains all the data used when passing a foobar around the Bitcoin network.
+///
+/// <details>
+/// <summary>FooBar Original Design</summary>
+///
+/// The foobar was introduced in Bitcoin x.y.z to increase the amount of foo in bar.
+///
+/// </details>
+///
+/// ### Relevant BIPs
+///
+/// * [BIP-XXXX - FooBar in Bitcoin](https://github.com/bitcoin/bips/blob/master/bip-xxxx.mediawiki)
+pub struct FooBar {
+    /// The version in use.
+    pub version: Version
+}
+```
+
+Do use rustdoc subheadings. Do put an empty newline below each heading e.g.,
+
+```rust
+impl FooBar {
+    /// Constructs a `FooBar` from a [`Baz`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `Baz` is not ...
+    ///
+    /// # Panics
+    ///
+    /// If the `Baz`, converted to a `usize`, is out of bounds.
+    pub fn from_baz(baz: Baz) -> Result<Self, Error> {
+        ...
+    }
+}
+```
+
+Note usage of third person instead of imperative.
+
+Good: `/// Calculates the distance to the moon.`
+Bad: `/// Calculate the distance to the moon.`
+
+Add Panics section if any input to the function can trigger a panic.
+
+Generally we prefer to have non-panicking APIs but it is impractical in some cases. If you're not
+sure, feel free to ask. If we determine panicking is more practical it must be documented. Internal
+panics that could theoretically occur because of bugs in our code must not be documented.
+
+Example code within the rustdocs should compile and lint with `just lint` without any errors or
+warnings.
+
+### Links
+
+We favour links at the bottom of the docs section:
+
+```rust
+    /// it is a real Taproot script spend (and not some other kind of output contrived
+    /// to have a Taproot-shaped witness). See [BIP-0341] in particular footnote 7, for
+    /// more information.
+    ///
+    /// [BIP-0341]: <https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki>
+```
+
+## Derives
+
+We try to use standard set of derives if it makes sense:
+
+```
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+enum Foo {
+    Bar,
+    Baz,
+}
+```
+
+For types that should not form a total or partial order, or that technically do but it does not
+make sense to compare them, we use the `Ordered` trait from the
+[`ordered`](https://crates.io/crates/ordered) crate. See `absolute::LockTime` for an example.
+
+For error types you likely want to use `#[derive(Debug, Clone, PartialEq, Eq)]`.
+
+See [Errors](#errors) section.
+
+
+## Attributes
+
+- `#[track_caller]`: Used on functions that panic on invalid arguments
+  (see https://rustc-dev-guide.rust-lang.org/backend/implicit-caller-location.html)
+
+- `#[cfg(rust_v_1_60)]`: Used to guard code that should only be built in if the toolchain is
+  compatible. These configuration conditionals are set at build time in `bitcoin/build.rs`. New
+  version attributes may be added as needed.
+
+
+## BIP References
+
+When referring to Bitcoin Improvement Proposals (BIPs) in documentation, comments, and error messages, use the standardized notation `BIP-XXXX` where `XXXX` is the 4-digit BIP number with leading zeros.
+
+### Examples
+
+- Correct: `BIP-0032`, `BIP-0341`, `BIP-0014`
+- Incorrect: `BIP32`, `BIP 341`, `Bip14`, `bip_341`
+
+### Exceptions
+
+Module names, function names, variable names, and file names must keep their existing lowercase/underscore format. Do not rename them to match the formal BIP style:
+- Module names: `bip32`, `bip152` (keep lowercase)
+- Function names: `bip32_derivation`, `bip_341_tests` (keep existing format)
+
+## Licensing
+
+We use SPDX license tags, all files should start with
+
+```
+// SPDX-License-Identifier: CC0-1.0
+```
diff --git a/docs/primitives.md b/docs/primitives.md
new file mode 100644
index 0000000000..98a169dcd3
--- /dev/null
+++ b/docs/primitives.md
@@ -0,0 +1,57 @@
+# primitives 1.0.0
+
+Design considerations and TODOs for the `bitcoin-primitives 1.0.0` release.
+
+## TODOs
+
+### consensus encoding
+
+GitHub discussion: https://github.com/rust-bitcoin/rust-bitcoin/discussions/4856
+
+Pull encoding done in: https://github.com/rust-bitcoin/rust-bitcoin/pull/4912
+
+### Remove `hashes` from the public API.
+
+Required due to [C-STABLE](https://rust-lang.github.io/api-guidelines/necessities.html#c-stable).
+
+Currently `hashes` shows up in the public API in all of our hash wrapper types. This can be seen by
+grepping the API text files introduced in
+[#4792](https://github.com/rust-bitcoin/rust-bitcoin/issues/4792) 
+
+The wrapper types are:
+
+```bash
+$ grep hashes api/primitives/all-features.txt | grep impl | awk '{print $NF}'
+
+bitcoin_primitives::block::BlockHash
+bitcoin_primitives::block::WitnessCommitment
+bitcoin_primitives::merkle_tree::TxMerkleNode
+bitcoin_primitives::merkle_tree::WitnessMerkleNode
+bitcoin_primitives::script::ScriptHash
+bitcoin_primitives::script::WScriptHash
+bitcoin_primitives::transaction::Ntxid
+bitcoin_primitives::transaction::Txid
+bitcoin_primitives::transaction::Wtxid
+```
+
+Using `Txid` as an example, `hashes` appears in the following places:
+
+```bash
+$ grep hashes api/primitives/all-features.txt | grep Txid
+
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
+pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+```
+
+All these come from the `hash_newtype` macro.
+
+Usage of `hash_newtype` in `bitcoin` (i.e. other usage outside of `primitives`):
+
+- `bip158::{FilterHash, FilterHeader}`
+- `bip32::XKeyIdentifier`
+- `crypto::key::{PubkeyHash, WPubkeyHash}`
+- `crypto::sighash::{LegacySighash, SegwitV0Sighash}`
+- `taproot::{TapLeafHash, TapNodeHash, TapTweakHash}`
diff --git a/docs/psbt.md b/docs/psbt.md
new file mode 100644
index 0000000000..6dbbf8504b
--- /dev/null
+++ b/docs/psbt.md
@@ -0,0 +1,8 @@
+# PSBT
+
+We would like to enable support for PSBTv2, not necessarily add support to `rust-bitcoin`.
+Potentially we want to split out the current PSBTv1 into a separate crate. The serialization logic
+likely stays in `rust-bitcoin`. There are various attempts at this in flight but mostly stale.
+
+* Initial support in `rust-bitcoin`: [#3507](https://github.com/rust-bitcoin/rust-bitcoin/pull/3507)
+* Initial PSBTV2 impl: https://github.com/tcharding/rust-psbt
diff --git a/docs/roadmap.md b/docs/roadmap.md
new file mode 100644
index 0000000000..d30afe2fa3
--- /dev/null
+++ b/docs/roadmap.md
@@ -0,0 +1,28 @@
+# `rust-bitcoin` repository roadmap
+
+* ~Release `units v1.0.0-rc.0`~
+* Create `bitcoin-consensus-encoding` `v0.1.0` (see [#4782])
+* Release `bitcoin-consensus-encoding` `v1.0.0-rc.0`
+* Release `primitives v1.0.0-rc.0`
+  * Implement script tagging
+  * Add support for consensus encoding to `primitives`
+* Release `bitcoin v0.33.0-rc.0`
+* Split out an address crate (see [addresses.md])
+* BIP-0032 and BIP-0380 (see [bip-32.md])
+* PSBTv2 (see [psbt.md])
+* Split out a crypto/keys crate. Includes discussion of `secp256k1`. See [crypto.md]
+* Make it possible for `bitcoin` to depend on `miniscript` (see [#2882])
+    - Requires [bip-32.md] and [psbt.md]
+* Disentangle and stabilize Taproot stuff (see [taproot.md])
+
+## RC cycle
+
+We want to do a long release candidate cycle to give time for downstream testing and feedback on the
+API of the 1.0 crates. At a minimum this will be 6 months from the release `primitives-1.0-rc.0`.
+
+[addresses.md]: ./addresses.md
+[bip-32.md]: ./bip-32.md
+[crypto.md]: ./crypto.md
+[psbt.md]: ./psbt.md
+[taproot.md]: ./taproot.md
+[#2882]: <https://github.com/rust-bitcoin/rust-bitcoin/issues/2882>
diff --git a/docs/supported-versions.md b/docs/supported-versions.md
new file mode 100644
index 0000000000..3f6c49ac00
--- /dev/null
+++ b/docs/supported-versions.md
@@ -0,0 +1,58 @@
+# Supported versions
+
+List of crates, their versions that we still actively maintain, and the dependency versions.
+
+## Bitcoin LTS versions
+
+- `v0.30` (Security and bug fixes only)
+- `v0.31` (Security and bug fixes only)
+- `v0.32`
+
+`v0.32` is the version most of the eccosystem is on. It is actively maintained. This means:
+
+1. Will backport anything that is easy enough if requested and if possible within semver rules.
+2. May attempt more involved backport work if we deem it important enough.
+3. Backport deprecations where possible as the API is developed to assist upgrade path.
+4. Security and bug fixes, obviously.
+
+(1) includes new features developed on `master`, so contributors are welcome to contribute a new
+feature with the explicit aim of then backporting it to `0.32`.
+
+## Dependency version map
+
+The LTS `bitcoin` releases and dependency versions (of crates in this repository).
+
+- `bitcoin 0.30`
+  -> `bitcoin-private 0.1`
+  -> `hashes 0.12`
+
+- `bitcoin 0.31`
+  -> `internals 0.2`
+  -> `hashes 0.13`
+
+- `bitcoin 0.32`
+  -> `base58ck 0.1`
+  -> `internals 0.3`
+  -> `io 0.1`
+  -> `units 0.1`
+  -> `hashes 0.14`
+
+Currently in development:
+
+- `bitcoin 0.33-rc.x`
+  -> `hashes 0.17`
+  -> `io 0.2`
+  -> `internals 0.4`
+  -> `primitives-1.0.0-rc.x`
+  -> `units-1.0.0-rc.x`
+  -> (transitively `consensus-encoding 1.0.0-rc.x`)
+
+Once the RC cycle is done:
+
+- `bitcoin 0.33`
+  -> `hashes 0.17`
+  -> `io 0.2`
+  -> `internals 0.4`
+  -> `primitives-1.0.0`
+  -> `units-1.0.0`
+  -> `consensus-encoding 1.0.0`
diff --git a/docs/taproot.md b/docs/taproot.md
new file mode 100644
index 0000000000..13c8452830
--- /dev/null
+++ b/docs/taproot.md
@@ -0,0 +1,14 @@
+# Taproot
+
+The `Taproot` code was left in `bitcoin` during the creation of
+`primitives` because it is not as close to stable.
+
+Furthermore the Taproot stuff is quite entangled in various places
+throughout the codebase which in turn entangles the `secp256k1`
+dependency.
+
+We likely need to tease apart the Taproot stuff and disentangle the
+bits we aren't yet willing to stabilize. Because of the entanglement
+this effects various other crates (`psbt`, `crypto`) as well as the
+stabilization efforts of script extension methods.
+
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index f69af96f7a..4c6ee387d3 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,6 +1,7 @@
 [package]
 name = "bitcoin-fuzz"
 edition = "2021"
+rust-version = "1.74.0"
 version = "0.0.1"
 authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
@@ -9,18 +10,38 @@ publish = false
 cargo-fuzz = true
 
 [dependencies]
-honggfuzz = { version = "0.5.56", default-features = false }
-bitcoin = { path = "../bitcoin", features = [ "serde" ] }
+honggfuzz = { version = "0.5.58", default-features = false }
+bitcoin = { path = "../bitcoin", features = [ "serde", "arbitrary" ] }
+p2p = { path = "../p2p", package = "bitcoin-p2p-messages", features = ["arbitrary"] }
+bitcoin_consensus_encoding = { path = "../consensus_encoding", package = "bitcoin-consensus-encoding" }
+arbitrary = { version = "1.4.1" }
 
-serde = { version = "1.0.103", features = [ "derive" ] }
-serde_json = "1.0"
+serde = { version = "1.0.195", features = [ "derive" ] }
+serde_json = "1.0.68"
+standard_test = "0.1.0"
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)'] }
 
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
+
+[[bin]]
+name = "bitcoin_arbitrary_block"
+path = "fuzz_targets/bitcoin/arbitrary_block.rs"
+
+[[bin]]
+name = "bitcoin_arbitrary_script"
+path = "fuzz_targets/bitcoin/arbitrary_script.rs"
+
+[[bin]]
+name = "bitcoin_arbitrary_transaction"
+path = "fuzz_targets/bitcoin/arbitrary_transaction.rs"
+
 [[bin]]
-name = "bitcoin_deserialize_address"
-path = "fuzz_targets/bitcoin/deserialize_address.rs"
+name = "bitcoin_arbitrary_witness"
+path = "fuzz_targets/bitcoin/arbitrary_witness.rs"
 
 [[bin]]
 name = "bitcoin_deserialize_block"
@@ -47,17 +68,33 @@ name = "bitcoin_deserialize_witness"
 path = "fuzz_targets/bitcoin/deserialize_witness.rs"
 
 [[bin]]
-name = "bitcoin_deser_net_msg"
-path = "fuzz_targets/bitcoin/deser_net_msg.rs"
+name = "bitcoin_parse_address"
+path = "fuzz_targets/bitcoin/parse_address.rs"
 
 [[bin]]
-name = "bitcoin_outpoint_string"
-path = "fuzz_targets/bitcoin/outpoint_string.rs"
+name = "bitcoin_parse_outpoint"
+path = "fuzz_targets/bitcoin/parse_outpoint.rs"
 
 [[bin]]
 name = "bitcoin_script_bytes_to_asm_fmt"
 path = "fuzz_targets/bitcoin/script_bytes_to_asm_fmt.rs"
 
+[[bin]]
+name = "consensus_encoding_decode_array"
+path = "fuzz_targets/consensus_encoding/decode_array.rs"
+
+[[bin]]
+name = "consensus_encoding_decode_byte_vec"
+path = "fuzz_targets/consensus_encoding/decode_byte_vec.rs"
+
+[[bin]]
+name = "consensus_encoding_decode_compact_size"
+path = "fuzz_targets/consensus_encoding/decode_compact_size.rs"
+
+[[bin]]
+name = "consensus_encoding_decode_decoder2"
+path = "fuzz_targets/consensus_encoding/decode_decoder2.rs"
+
 [[bin]]
 name = "hashes_json"
 path = "fuzz_targets/hashes/json.rs"
@@ -74,14 +111,38 @@ path = "fuzz_targets/hashes/sha1.rs"
 name = "hashes_sha256"
 path = "fuzz_targets/hashes/sha256.rs"
 
+[[bin]]
+name = "hashes_sha512"
+path = "fuzz_targets/hashes/sha512.rs"
+
 [[bin]]
 name = "hashes_sha512_256"
 path = "fuzz_targets/hashes/sha512_256.rs"
 
 [[bin]]
-name = "hashes_sha512"
-path = "fuzz_targets/hashes/sha512.rs"
+name = "p2p_arbitrary_addrv2"
+path = "fuzz_targets/p2p/arbitrary_addrv2.rs"
+
+[[bin]]
+name = "p2p_deserialize_addrv2"
+path = "fuzz_targets/p2p/deserialize_addrv2.rs"
+
+[[bin]]
+name = "p2p_deserialize_raw_net_msg"
+path = "fuzz_targets/p2p/deserialize_raw_net_msg.rs"
+
+[[bin]]
+name = "units_arbitrary_weight"
+path = "fuzz_targets/units/arbitrary_weight.rs"
+
+[[bin]]
+name = "units_parse_amount"
+path = "fuzz_targets/units/parse_amount.rs"
+
+[[bin]]
+name = "units_parse_int"
+path = "fuzz_targets/units/parse_int.rs"
 
 [[bin]]
-name = "units_deserialize_amount"
-path = "fuzz_targets/units/deserialize_amount.rs"
+name = "units_standard_checks"
+path = "fuzz_targets/units/standard_checks.rs"
diff --git a/fuzz/fuzz-util.sh b/fuzz/fuzz-util.sh
index 759d41c4d6..df53addebe 100755
--- a/fuzz/fuzz-util.sh
+++ b/fuzz/fuzz-util.sh
@@ -1,5 +1,9 @@
 #!/usr/bin/env bash
 
+# Sort order is affected by locale. See `man sort`.
+# > Set LC_ALL=C to get the traditional sort order that uses native byte values.
+export LC_ALL=C
+
 REPO_DIR=$(git rev-parse --show-toplevel)
 
 listTargetFiles() {
@@ -16,14 +20,6 @@ targetFileToName() {
     | sed 's/^_//g'
 }
 
-targetFileToHFuzzInputArg() {
-  baseName=$(basename "$1")
-  dirName="${baseName%.*}"
-  if [ -d "hfuzz_input/$dirName" ]; then
-    echo "HFUZZ_INPUT_ARGS=\"-f hfuzz_input/$FILE/input\""
-  fi
-}
-
 listTargetNames() {
   for target in $(listTargetFiles); do
     targetFileToName "$target"
@@ -39,7 +35,7 @@ checkWindowsFiles() {
   fi
 }
 
-# Checks whether a fuzz case output some report, and dumps it in hex
+# Checks whether a fuzz case outputs some report, and dumps it in hex
 checkReport() {
   reportFile="hfuzz_workspace/$1/HONGGFUZZ.REPORT.TXT"
   if [ -f "$reportFile" ]; then
diff --git a/fuzz/fuzz.sh b/fuzz/fuzz.sh
index 22ced4de72..897b29a00b 100755
--- a/fuzz/fuzz.sh
+++ b/fuzz/fuzz.sh
@@ -25,7 +25,7 @@ for targetFile in $targetFiles; do
   targetName=$(targetFileToName "$targetFile")
   echo "Fuzzing target $targetName ($targetFile)"
   if [ -d "hfuzz_input/$targetName" ]; then
-    HFUZZ_INPUT_ARGS="-f hfuzz_input/$targetName/input\""
+    HFUZZ_INPUT_ARGS="-f hfuzz_input/$targetName/input"
   else
     HFUZZ_INPUT_ARGS=""
   fi
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs
new file mode 100644
index 0000000000..6c66bbc611
--- /dev/null
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs
@@ -0,0 +1,64 @@
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::block::{self, Block, BlockCheckedExt as _};
+use bitcoin::consensus::{deserialize, serialize};
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+    let b = Block::arbitrary(&mut u);
+
+    if let Ok(block) = b {
+        let serialized = serialize(&block);
+
+        // Manually call all compute functions with unchecked block data.
+        let (header, transactions) = block.clone().into_parts();
+        block::compute_merkle_root(&transactions);
+        // Use 32-byte zero array as witness_reserved_value per BIP-0141 requirement.
+        block.compute_witness_commitment(&[0u8; 32]);
+        block::compute_witness_root(&transactions);
+
+        if let Ok(block) = Block::new_checked(header, transactions) {
+            let _ = block.bip34_block_height();
+            block.block_hash();
+            block.weight();
+        }
+
+        let deserialized: Result<Block, _> = deserialize(serialized.as_slice());
+        assert_eq!(deserialized.unwrap(), block);
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
new file mode 100644
index 0000000000..4fd4dc07c8
--- /dev/null
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
@@ -0,0 +1,84 @@
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::address::Address;
+use bitcoin::consensus::serialize;
+use bitcoin::script::{self, ScriptBuf, ScriptExt as _, ScriptPubKeyExt as _};
+use bitcoin::Network;
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+    let s = ScriptBuf::arbitrary(&mut u);
+
+    if let Ok(script_buf) = s {
+        let serialized = serialize(&script_buf);
+        let _: Result<Vec<script::Instruction>, script::Error> =
+            script_buf.instructions().collect();
+
+        let _ = script_buf.to_string();
+        let _ = script_buf.count_sigops();
+        let _ = script_buf.count_sigops_legacy();
+        let _ = script_buf.minimal_non_dust();
+        let _ = script_buf.minimal_non_dust_custom(u.arbitrary().expect("valid arbitrary FeeRate"));
+
+        let mut builder = script::Builder::new();
+        for instruction in script_buf.instructions_minimal() {
+            if instruction.is_err() {
+                return;
+            }
+            match instruction.ok().unwrap() {
+                script::Instruction::Op(op) => {
+                    builder = builder.push_opcode(op);
+                }
+                script::Instruction::PushBytes(bytes) => {
+                    // While we enforce the minimality rule for minimal PUSHDATA opcodes, we don't
+                    // enforce the minimality of numbers since we don't have a script engine
+                    // to determine if the number is getting fed into a numeric opcode, which is
+                    // when the minimality of numbers is required.
+                    builder = builder.push_slice_non_minimal(bytes)
+                }
+            }
+        }
+        assert_eq!(builder.into_script(), script_buf);
+        assert_eq!(serialized, &serialize(&script_buf)[..]);
+
+        // Check if valid address and if that address roundtrips.
+        if let Ok(addr) = Address::from_script(&script_buf, Network::Bitcoin) {
+            assert_eq!(addr.script_pubkey(), script_buf);
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs
new file mode 100644
index 0000000000..be1005dfee
--- /dev/null
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs
@@ -0,0 +1,67 @@
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::transaction::TransactionExt as _;
+use bitcoin::Transaction;
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+    let t = Transaction::arbitrary(&mut u);
+
+    if let Ok(mut tx) = t {
+        let serialized = serialize(&tx);
+        let deserialized: Result<Transaction, _> = deserialize(serialized.as_slice());
+        assert_eq!(deserialized.unwrap(), tx);
+
+        let len = serialized.len();
+        let calculated_weight = tx.weight().to_wu() as usize;
+        for input in &mut tx.inputs {
+            input.witness = bitcoin::witness::Witness::default();
+        }
+        let no_witness_len = bitcoin::consensus::encode::serialize(&tx).len();
+        // For 0-input transactions, `no_witness_len` will be incorrect because
+        // we serialize as SegWit even after "stripping the witnesses". We need
+        // to drop two bytes (i.e. eight weight). Similarly, calculated_weight is
+        // incorrect and needs 2 wu removing for the marker/flag bytes.
+        if tx.inputs.is_empty() {
+            assert_eq!(no_witness_len * 3 + len - 8, calculated_weight - 2);
+        } else {
+            assert_eq!(no_witness_len * 3 + len, calculated_weight);
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs
new file mode 100644
index 0000000000..f4308ed770
--- /dev/null
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs
@@ -0,0 +1,58 @@
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::blockdata::witness::WitnessExt;
+use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::Witness;
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+
+    if let Ok(mut witness) = Witness::arbitrary(&mut u) {
+        let serialized = serialize(&witness);
+
+        let _ = witness.witness_script();
+        let _ = witness.taproot_leaf_script();
+
+        let deserialized: Result<Witness, _> = deserialize(serialized.as_slice());
+        assert_eq!(deserialized.unwrap(), witness);
+
+        if let Ok(element_bytes) = Vec::<u8>::arbitrary(&mut u) {
+            witness.push(element_bytes.as_slice());
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_block.rs b/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
index 2ad53e8d71..c9725106fc 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
@@ -1,27 +1,13 @@
-use bitcoin::block::{self, Block, BlockCheckedExt as _};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let block_result: Result<bitcoin::block::Block, _> =
-        bitcoin::consensus::encode::deserialize(data);
+    let block_result: Result<bitcoin::Block, _> = bitcoin::consensus::encode::deserialize(data);
 
     match block_result {
         Err(_) => {}
         Ok(block) => {
             let ser = bitcoin::consensus::encode::serialize(&block);
             assert_eq!(&ser[..], data);
-
-            // Manually call all compute functions with unchecked block data.
-            let (header, transactions) = block.into_parts();
-            block::compute_merkle_root(&transactions);
-            block::compute_witness_commitment(&transactions, &[]); // TODO: Is empty slice ok?
-            block::compute_witness_root(&transactions);
-
-            if let Ok(block) = Block::new_checked(header, transactions) {
-                let _ = block.bip34_block_height();
-                block.block_hash();
-                block.weight();
-            }
         }
     }
 }
@@ -56,7 +42,7 @@ mod tests {
     #[test]
     fn duplicate_crash() {
         let mut a = Vec::new();
-        extend_vec_from_hex("00", &mut a);
+        extend_vec_from_hex("000700000001000000010000", &mut a);
         super::do_test(&a);
     }
 }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_prefilled_transaction.rs b/fuzz/fuzz_targets/bitcoin/deserialize_prefilled_transaction.rs
index 9e8ae790f7..948f77ef86 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_prefilled_transaction.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_prefilled_transaction.rs
@@ -2,7 +2,7 @@ use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     // We already fuzz Transactions in `./deserialize_transaction.rs`.
-    let tx_result: Result<bitcoin::bip152::PrefilledTransaction, _> =
+    let tx_result: Result<p2p::bip152::PrefilledTransaction, _> =
         bitcoin::consensus::encode::deserialize(data);
 
     match tx_result {
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 41ef804933..407d03c746 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -1,56 +1,14 @@
-use bitcoin::address::Address;
-use bitcoin::consensus::encode;
-use bitcoin::script::{self, ScriptExt as _};
-use bitcoin::{FeeRate, Network};
-use bitcoin_fuzz::fuzz_utils::{consume_random_bytes, consume_u64};
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let mut new_data = data;
-    let bytes = consume_random_bytes(&mut new_data);
-    let s: Result<script::ScriptBuf, _> = encode::deserialize(bytes);
-    if let Ok(script) = s {
-        let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
-
-        let _ = script.to_string();
-        let _ = script.count_sigops();
-        let _ = script.count_sigops_legacy();
-        let _ = script.minimal_non_dust();
-
-        let fee_rate = FeeRate::from_sat_per_kwu(consume_u64(&mut new_data));
-        let _ = script.minimal_non_dust_custom(fee_rate);
-
-        let mut b = script::Builder::new();
-        for ins in script.instructions_minimal() {
-            if ins.is_err() {
-                return;
-            }
-            match ins.ok().unwrap() {
-                script::Instruction::Op(op) => {
-                    b = b.push_opcode(op);
-                }
-                script::Instruction::PushBytes(bytes) => {
-                    // Any one-byte pushes, except -0, which can be interpreted as numbers, should be
-                    // reserialized as numbers. (For -1 through 16, this will use special ops; for
-                    // others it'll just reserialize them as pushes.)
-                    if bytes.len() == 1 && bytes[0] != 0x80 && bytes[0] != 0x00 {
-                        if let Ok(num) = bytes.read_scriptint() {
-                            b = b.push_int_unchecked(num);
-                        } else {
-                            b = b.push_slice(bytes);
-                        }
-                    } else {
-                        b = b.push_slice(bytes);
-                    }
-                }
-            }
-        }
-        assert_eq!(b.into_script(), script);
-        assert_eq!(data, &encode::serialize(&script)[..]);
-
-        // Check if valid address and if that address roundtrips.
-        if let Ok(addr) = Address::from_script(&script, Network::Bitcoin) {
-            assert_eq!(addr.script_pubkey(), script);
+    let script_result: Result<bitcoin::ScriptPubKeyBuf, _> =
+        bitcoin::consensus::encode::deserialize(data);
+
+    match script_result {
+        Err(_) => {}
+        Ok(script) => {
+            let ser = bitcoin::consensus::encode::serialize(&script);
+            assert_eq!(&ser[..], data);
         }
     }
 }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
index c37e8e7e21..340b596bdc 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
@@ -1,29 +1,13 @@
-use bitcoin::transaction::TransactionExt as _;
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let tx_result: Result<bitcoin::transaction::Transaction, _> =
-        bitcoin::consensus::encode::deserialize(data);
+    let tx_result: Result<bitcoin::Transaction, _> = bitcoin::consensus::encode::deserialize(data);
+
     match tx_result {
         Err(_) => {}
-        Ok(mut tx) => {
+        Ok(tx) => {
             let ser = bitcoin::consensus::encode::serialize(&tx);
             assert_eq!(&ser[..], data);
-            let len = ser.len();
-            let calculated_weight = tx.weight().to_wu() as usize;
-            for input in &mut tx.input {
-                input.witness = bitcoin::witness::Witness::default();
-            }
-            let no_witness_len = bitcoin::consensus::encode::serialize(&tx).len();
-            // For 0-input transactions, `no_witness_len` will be incorrect because
-            // we serialize as SegWit even after "stripping the witnesses". We need
-            // to drop two bytes (i.e. eight weight). Similarly, calculated_weight is
-            // incorrect and needs 2 wu removing for the marker/flag bytes.
-            if tx.input.is_empty() {
-                assert_eq!(no_witness_len * 3 + len - 8, calculated_weight - 2);
-            } else {
-                assert_eq!(no_witness_len * 3 + len, calculated_weight);
-            }
         }
     }
 }
@@ -58,7 +42,7 @@ mod tests {
     #[test]
     fn duplicate_crash() {
         let mut a = Vec::new();
-        extend_vec_from_hex("000700000001000000010000", &mut a);
+        extend_vec_from_hex("00", &mut a);
         super::do_test(&a);
     }
 }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs b/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
index 9dec1bc684..ecc59b9e6a 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
@@ -1,12 +1,15 @@
-use bitcoin::consensus::{deserialize, serialize};
 use bitcoin::witness::Witness;
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let w: Result<Witness, _> = deserialize(data);
-    if let Ok(witness) = w {
-        let serialized = serialize(&witness);
-        assert_eq!(data, &serialized[..]);
+    let witness_result: Result<Witness, _> = bitcoin::consensus::encode::deserialize(data);
+
+    match witness_result {
+        Err(_) => {}
+        Ok(witness) => {
+            let ser = bitcoin::consensus::encode::serialize(&witness);
+            assert_eq!(&ser[..], data);
+        }
     }
 }
 
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_address.rs b/fuzz/fuzz_targets/bitcoin/parse_address.rs
similarity index 100%
rename from fuzz/fuzz_targets/bitcoin/deserialize_address.rs
rename to fuzz/fuzz_targets/bitcoin/parse_address.rs
diff --git a/fuzz/fuzz_targets/bitcoin/outpoint_string.rs b/fuzz/fuzz_targets/bitcoin/parse_outpoint.rs
similarity index 100%
rename from fuzz/fuzz_targets/bitcoin/outpoint_string.rs
rename to fuzz/fuzz_targets/bitcoin/parse_outpoint.rs
diff --git a/fuzz/fuzz_targets/bitcoin/script_bytes_to_asm_fmt.rs b/fuzz/fuzz_targets/bitcoin/script_bytes_to_asm_fmt.rs
index db021a76db..07b4d1f817 100644
--- a/fuzz/fuzz_targets/bitcoin/script_bytes_to_asm_fmt.rs
+++ b/fuzz/fuzz_targets/bitcoin/script_bytes_to_asm_fmt.rs
@@ -1,6 +1,5 @@
-use std::fmt;
+use std::fmt::{self, Write as _};
 
-use bitcoin::script::ScriptExt as _;
 use honggfuzz::fuzz;
 
 // faster than String, we don't need to actually produce the value, just check absence of panics
@@ -14,7 +13,8 @@ impl fmt::Write for NullWriter {
 
 fn do_test(data: &[u8]) {
     let mut writer = NullWriter;
-    bitcoin::Script::from_bytes(data).fmt_asm(&mut writer).unwrap();
+    let script = bitcoin::WitnessScript::from_bytes(data);
+    write!(writer, "{script}").unwrap();
 }
 
 fn main() {
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_array.rs b/fuzz/fuzz_targets/consensus_encoding/decode_array.rs
new file mode 100644
index 0000000000..d994538646
--- /dev/null
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_array.rs
@@ -0,0 +1,85 @@
+use bitcoin_consensus_encoding::{ArrayDecoder, Decoder};
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    test_array_decoder::<1>(data);
+    test_array_decoder::<2>(data);
+    test_array_decoder::<4>(data);
+    test_array_decoder::<8>(data);
+    test_array_decoder::<16>(data);
+    test_array_decoder::<32>(data);
+}
+
+fn test_array_decoder<const N: usize>(data: &[u8]) {
+    let mut decoder = ArrayDecoder::<N>::new();
+    let mut remaining = data;
+    let push_result = decoder.push_bytes(&mut remaining);
+
+    match push_result {
+        Err(_) => {
+            // Expected for invalid data or other parsing errors.
+        }
+        Ok(needs_more) => {
+            if needs_more {
+                // Decoder needs more data, but we've given it all we have
+                // This should result in an error when we call end().
+                let end_result = decoder.end();
+                assert!(
+                    end_result.is_err(),
+                    "decoder should error when insufficient data provided"
+                );
+            } else {
+                let end_result = decoder.end();
+                match end_result {
+                    Err(_) => {
+                        // Unexpected, but could happen due to internal state issues.
+                    }
+                    Ok(array) => {
+                        // Verify the array has the expected size.
+                        assert_eq!(array.len(), N);
+                        // Verify the array contains the expected data from input.
+                        if data.len() >= N {
+                            assert_eq!(&array[..], &data[..N]);
+                            assert_eq!(&data[N..], remaining);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("deadbeef", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs b/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs
new file mode 100644
index 0000000000..6119cbb431
--- /dev/null
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs
@@ -0,0 +1,74 @@
+use bitcoin_consensus_encoding::{ByteVecDecoder, Decoder};
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut decoder = ByteVecDecoder::new();
+    let mut remaining = data;
+    let push_result = decoder.push_bytes(&mut remaining);
+
+    match push_result {
+        Err(_) => {
+            // Expected for invalid data or allocation limits.
+        }
+        Ok(needs_more) => {
+            if needs_more {
+                // Decoder needs more data, but we've given it all we have
+                // This should result in an error when we call end().
+                let end_result = decoder.end();
+                assert!(
+                    end_result.is_err(),
+                    "decoder should error when insufficient data provided"
+                );
+            } else {
+                let end_result = decoder.end();
+                match end_result {
+                    Err(_) => {
+                        // Could happen for invalid compact size formats.
+                    }
+                    Ok(vec) => {
+                        // Validate that result makes sense, can't produce more data than input and 32MB limit.
+                        assert!(vec.len() <= data.len());
+                        if !vec.is_empty() {
+                            assert!(vec.len() <= 0x02000000);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("03010203", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs b/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs
new file mode 100644
index 0000000000..e747495c79
--- /dev/null
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs
@@ -0,0 +1,84 @@
+use bitcoin_consensus_encoding::{CompactSizeDecoder, Decoder};
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut decoder = CompactSizeDecoder::new();
+    let mut remaining = data;
+    let push_result = decoder.push_bytes(&mut remaining);
+
+    match push_result {
+        Err(_) => {
+            // Expected for invalid compact size encodings.
+        }
+        Ok(needs_more) => {
+            if needs_more {
+                // Decoder needs more data, but we've given it all we have
+                // This should result in an error when we call end().
+                let end_result = decoder.end();
+                assert!(
+                    end_result.is_err(),
+                    "decoder should error when insufficient data provided"
+                );
+            } else {
+                let end_result = decoder.end();
+                match end_result {
+                    Err(_) => {
+                        // Could happen for invalid compact size formats.
+                    }
+                    Ok(value) => {
+                        // Verify the value is reasonable based on encoding size.
+                        let consumed = data.len() - remaining.len();
+                        assert!((1..=9).contains(&consumed));
+
+                        match consumed {
+                            1 => assert!(value < 0xFD),
+                            3 => assert!((0xFD..=0xFFFF).contains(&value)),
+                            5 => assert!((0x10000..=0xFFFFFFFF).contains(&value)),
+                            9 => assert!((value as u64) >= 0x100000000), // Decoded values should only ever fit into a u64
+                            _ => panic!("invalid compact size encoding length: {}", consumed),
+                        }
+
+                        if data.len() >= consumed {
+                            assert_eq!(&data[consumed..], remaining);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("fd0000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs b/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs
new file mode 100644
index 0000000000..774b3000df
--- /dev/null
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs
@@ -0,0 +1,75 @@
+use bitcoin_consensus_encoding::{ArrayDecoder, Decoder, Decoder2};
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut decoder = Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
+    let mut remaining = data;
+
+    let push_result = decoder.push_bytes(&mut remaining);
+
+    match push_result {
+        Err(_) => {
+            // Expected for invalid data
+        }
+        Ok(needs_more) => {
+            if needs_more {
+                let end_result = decoder.end();
+                assert!(
+                    end_result.is_err(),
+                    "decoder should error when insufficient data provided"
+                );
+            } else {
+                let end_result = decoder.end();
+                match end_result {
+                    Err(_) => {
+                        // Unexpected for array decoders with sufficient data.
+                    }
+                    Ok((first_array, second_array)) => {
+                        assert_eq!(first_array.len(), 2);
+                        assert_eq!(second_array.len(), 3);
+                        if data.len() >= 5 {
+                            assert_eq!(&data[5..], remaining);
+                            assert_eq!(&first_array[..], &data[..2]);
+                            assert_eq!(&second_array[..], &data[2..5]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("0102030405", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/p2p/arbitrary_addrv2.rs b/fuzz/fuzz_targets/p2p/arbitrary_addrv2.rs
new file mode 100644
index 0000000000..31f4fa56cb
--- /dev/null
+++ b/fuzz/fuzz_targets/p2p/arbitrary_addrv2.rs
@@ -0,0 +1,72 @@
+use std::convert::TryFrom;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+use arbitrary::{Arbitrary, Unstructured};
+use honggfuzz::fuzz;
+use p2p::address::AddrV2;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+    let a = AddrV2::arbitrary(&mut u);
+
+    if let Ok(addr_v2) = a {
+        if let Ok(ip_addr) = IpAddr::try_from(addr_v2.clone()) {
+            let round_trip: AddrV2 = AddrV2::from(ip_addr);
+            assert_eq!(
+                addr_v2, round_trip,
+                "AddrV2 -> IpAddr -> AddrV2 should round-trip correctly"
+            );
+        }
+
+        if let Ok(ip_addr) = Ipv4Addr::try_from(addr_v2.clone()) {
+            let round_trip: AddrV2 = AddrV2::from(ip_addr);
+            assert_eq!(
+                addr_v2, round_trip,
+                "AddrV2 -> Ipv4Addr -> AddrV2 should round-trip correctly"
+            );
+        }
+
+        if let Ok(ip_addr) = Ipv6Addr::try_from(addr_v2.clone()) {
+            let round_trip: AddrV2 = AddrV2::from(ip_addr);
+            assert_eq!(
+                addr_v2, round_trip,
+                "AddrV2 -> Ipv6Addr -> AddrV2 should round-trip correctly"
+            );
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/p2p/deserialize_addrv2.rs b/fuzz/fuzz_targets/p2p/deserialize_addrv2.rs
new file mode 100644
index 0000000000..6f4577dcdd
--- /dev/null
+++ b/fuzz/fuzz_targets/p2p/deserialize_addrv2.rs
@@ -0,0 +1,40 @@
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let _: Result<p2p::address::AddrV2, _> = bitcoin::consensus::encode::deserialize(data);
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/bitcoin/deser_net_msg.rs b/fuzz/fuzz_targets/p2p/deserialize_raw_net_msg.rs
similarity index 93%
rename from fuzz/fuzz_targets/bitcoin/deser_net_msg.rs
rename to fuzz/fuzz_targets/p2p/deserialize_raw_net_msg.rs
index 906bcee9f5..635a4a7a08 100644
--- a/fuzz/fuzz_targets/bitcoin/deser_net_msg.rs
+++ b/fuzz/fuzz_targets/p2p/deserialize_raw_net_msg.rs
@@ -1,7 +1,7 @@
 use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let _: Result<bitcoin::p2p::message::RawNetworkMessage, _> =
+    let _: Result<p2p::message::RawNetworkMessage, _> =
         bitcoin::consensus::encode::deserialize(data);
 }
 
diff --git a/fuzz/fuzz_targets/units/arbitrary_weight.rs b/fuzz/fuzz_targets/units/arbitrary_weight.rs
new file mode 100644
index 0000000000..93ce2d82de
--- /dev/null
+++ b/fuzz/fuzz_targets/units/arbitrary_weight.rs
@@ -0,0 +1,87 @@
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::Weight;
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+    let w = Weight::arbitrary(&mut u);
+
+    if let Ok(weight) = w {
+        weight.to_wu();
+        weight.to_kwu_ceil();
+        weight.to_kwu_floor();
+        weight.to_vbytes_ceil();
+        weight.to_vbytes_floor();
+
+        // Operations that take u64 as the rhs
+        for operation in [Weight::checked_mul, Weight::checked_div] {
+            if let Ok(val) = u.arbitrary() {
+                let _ = operation(weight, val);
+            } else {
+                return;
+            }
+        }
+
+        // Operations that take Weight as the rhs
+        for operation in [Weight::checked_add, Weight::checked_sub] {
+            if let Ok(val) = u.arbitrary() {
+                let _ = operation(weight, val);
+            } else {
+                return;
+            }
+        }
+    }
+
+    // Constructors that return a Weight
+    for constructor in [Weight::from_wu] {
+        if let Ok(val) = u.arbitrary() {
+            constructor(val);
+        } else {
+            return;
+        }
+    }
+
+    // Constructors that return an Option<Weight>
+    for constructor in [Weight::from_vb, Weight::from_kwu] {
+        if let Ok(val) = u.arbitrary() {
+            constructor(val);
+        } else {
+            return;
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/units/deserialize_amount.rs b/fuzz/fuzz_targets/units/parse_amount.rs
similarity index 100%
rename from fuzz/fuzz_targets/units/deserialize_amount.rs
rename to fuzz/fuzz_targets/units/parse_amount.rs
diff --git a/fuzz/fuzz_targets/units/parse_int.rs b/fuzz/fuzz_targets/units/parse_int.rs
new file mode 100644
index 0000000000..7d3e826f17
--- /dev/null
+++ b/fuzz/fuzz_targets/units/parse_int.rs
@@ -0,0 +1,106 @@
+use arbitrary::Unstructured;
+use bitcoin::parse_int;
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let mut u = Unstructured::new(data);
+
+    if let Ok(s) = u.arbitrary::<&str>() {
+        let _ = parse_int::int_from_str::<i8>(s);
+        let _ = parse_int::int_from_str::<i16>(s);
+        let _ = parse_int::int_from_str::<i32>(s);
+        let _ = parse_int::int_from_str::<i64>(s);
+        let _ = parse_int::int_from_str::<i128>(s);
+
+        let _ = parse_int::int_from_str::<u8>(s);
+        let _ = parse_int::int_from_str::<u16>(s);
+        let _ = parse_int::int_from_str::<u32>(s);
+        let _ = parse_int::int_from_str::<u64>(s);
+        let _ = parse_int::int_from_str::<u128>(s);
+
+        let _ = parse_int::hex_remove_prefix(s);
+
+        if parse_int::hex_u32_prefixed(s).is_ok() {
+            assert!(parse_int::hex_u32(s).is_ok());
+            assert!(parse_int::hex_u32_unprefixed(s).is_err());
+        }
+
+        if parse_int::hex_u32_unprefixed(s).is_ok() {
+            assert!(parse_int::hex_u32(s).is_ok());
+            assert!(parse_int::hex_u32_prefixed(s).is_err());
+        }
+
+        if parse_int::hex_u128_prefixed(s).is_ok() {
+            assert!(parse_int::hex_u128(s).is_ok());
+            assert!(parse_int::hex_u128_unprefixed(s).is_err());
+        }
+
+        if parse_int::hex_u128_unprefixed(s).is_ok() {
+            assert!(parse_int::hex_u128(s).is_ok());
+            assert!(parse_int::hex_u128_prefixed(s).is_err());
+        }
+    }
+
+    if let Ok(s) = u.arbitrary::<String>() {
+        let _ = parse_int::int_from_string::<i8>(s.clone());
+        let _ = parse_int::int_from_string::<i16>(s.clone());
+        let _ = parse_int::int_from_string::<i32>(s.clone());
+        let _ = parse_int::int_from_string::<i64>(s.clone());
+        let _ = parse_int::int_from_string::<i128>(s.clone());
+
+        let _ = parse_int::int_from_string::<u8>(s.clone());
+        let _ = parse_int::int_from_string::<u16>(s.clone());
+        let _ = parse_int::int_from_string::<u32>(s.clone());
+        let _ = parse_int::int_from_string::<u64>(s.clone());
+        let _ = parse_int::int_from_string::<u128>(s);
+    }
+
+    if let Ok(s) = u.arbitrary::<Box<str>>() {
+        let _ = parse_int::int_from_box::<i8>(s.clone());
+        let _ = parse_int::int_from_box::<i16>(s.clone());
+        let _ = parse_int::int_from_box::<i32>(s.clone());
+        let _ = parse_int::int_from_box::<i64>(s.clone());
+        let _ = parse_int::int_from_box::<i128>(s.clone());
+
+        let _ = parse_int::int_from_box::<u8>(s.clone());
+        let _ = parse_int::int_from_box::<u16>(s.clone());
+        let _ = parse_int::int_from_box::<u32>(s.clone());
+        let _ = parse_int::int_from_box::<u64>(s.clone());
+        let _ = parse_int::int_from_box::<u128>(s);
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/units/standard_checks.rs b/fuzz/fuzz_targets/units/standard_checks.rs
new file mode 100644
index 0000000000..24b1c91747
--- /dev/null
+++ b/fuzz/fuzz_targets/units/standard_checks.rs
@@ -0,0 +1,121 @@
+use bitcoin::absolute::{Height, MedianTimePast};
+use bitcoin::relative::{NumberOf512Seconds, NumberOfBlocks};
+use bitcoin::{
+    Amount, BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime, FeeRate,
+    Sequence, SignedAmount, Weight,
+};
+use honggfuzz::fuzz;
+use standard_test::StandardChecks as _;
+
+/// Implements the traits on the wrapper type $ty. Intended only to be called from inside wrap_for_checks!
+macro_rules! _impl_traits_on_wrapper {
+    ($ty:ident$(, $default:expr)?) => {
+        impl<'a> arbitrary::Arbitrary<'a> for $ty {
+            fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+                Ok(Self(super::$ty::arbitrary(u)?))
+            }
+        }
+
+        impl core::ops::Deref for $ty {
+            type Target = super::$ty;
+
+            fn deref(&self) -> &Self::Target { &self.0 }
+        }
+
+        $(
+            impl Default for $ty {
+                fn default() -> $ty { Self($default) }
+            }
+        )?
+
+        standard_checks!($ty);
+    };
+}
+
+/// Create a wrapper type for a foreign type so that we can use standard_checks! on it from here.
+macro_rules! wrap_for_checks {
+    ($ty:ident) => {
+        #[derive(Default)]
+        pub(crate) struct $ty(super::$ty);
+
+        _impl_traits_on_wrapper!($ty);
+    };
+    ($ty:ident, $default:expr) => {
+        pub(crate) struct $ty(super::$ty);
+
+        _impl_traits_on_wrapper!($ty, $default);
+    };
+}
+
+mod fuzz {
+    use standard_test::standard_checks;
+
+    wrap_for_checks!(Amount);
+    wrap_for_checks!(BlockHeightInterval);
+    wrap_for_checks!(BlockMtpInterval);
+    wrap_for_checks!(NumberOf512Seconds);
+    wrap_for_checks!(NumberOfBlocks);
+    wrap_for_checks!(Sequence);
+    wrap_for_checks!(SignedAmount);
+
+    // Structs that need defaults
+    wrap_for_checks!(BlockHeight, super::BlockHeight::MIN);
+    wrap_for_checks!(BlockMtp, super::BlockMtp::from_u32(1_742_979_600)); // 26 Mar 2025 9:00 UTC
+    wrap_for_checks!(BlockTime, super::BlockTime::from(1_742_979_600)); // 26 Mar 2025 9:00 UTC
+    wrap_for_checks!(FeeRate, super::FeeRate::BROADCAST_MIN);
+    wrap_for_checks!(Height, super::Height::MIN);
+    wrap_for_checks!(MedianTimePast, super::MedianTimePast::MIN);
+    wrap_for_checks!(Weight, super::Weight::MIN_TRANSACTION);
+}
+
+fn do_test(data: &[u8]) {
+    fuzz::Amount::one_iteration(data);
+    fuzz::BlockHeight::one_iteration(data);
+    fuzz::BlockHeightInterval::one_iteration(data);
+    fuzz::BlockMtp::one_iteration(data);
+    fuzz::BlockMtpInterval::one_iteration(data);
+    fuzz::BlockTime::one_iteration(data);
+    fuzz::FeeRate::one_iteration(data);
+    fuzz::Height::one_iteration(data);
+    fuzz::NumberOf512Seconds::one_iteration(data);
+    fuzz::NumberOfBlocks::one_iteration(data);
+    fuzz::MedianTimePast::one_iteration(data);
+    fuzz::Sequence::one_iteration(data);
+    fuzz::SignedAmount::one_iteration(data);
+    fuzz::Weight::one_iteration(data);
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
index e85f20ed54..4d43823766 100755
--- a/fuzz/generate-files.sh
+++ b/fuzz/generate-files.sh
@@ -13,7 +13,7 @@ cat > "$REPO_DIR/fuzz/Cargo.toml" <<EOF
 [package]
 name = "bitcoin-fuzz"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 version = "0.0.1"
 authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
@@ -22,14 +22,22 @@ publish = false
 cargo-fuzz = true
 
 [dependencies]
-honggfuzz = { version = "0.5.55", default-features = false }
-bitcoin = { path = "../bitcoin", features = [ "serde" ] }
+honggfuzz = { version = "0.5.58", default-features = false }
+bitcoin = { path = "../bitcoin", features = [ "serde", "arbitrary" ] }
+p2p = { path = "../p2p", package = "bitcoin-p2p-messages", features = ["arbitrary"] }
+bitcoin_consensus_encoding = { path = "../consensus_encoding", package = "bitcoin-consensus-encoding" }
+arbitrary = { version = "1.4.1" }
 
-serde = { version = "1.0.103", features = [ "derive" ] }
-serde_json = "1.0"
+serde = { version = "1.0.195", features = [ "derive" ] }
+serde_json = "1.0.68"
+standard_test = "0.1.0"
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)'] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
 EOF
 
 for targetFile in $(listTargetFiles); do
@@ -53,11 +61,14 @@ on:
     # - 6am CET
     # - 4pm AEDT
     - cron: '00 05 * * *'
+permissions: {}
 
 jobs:
   fuzz:
     if: \${{ !github.event.act }}
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     strategy:
       fail-fast: false
       matrix:
@@ -69,8 +80,11 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
     steps:
       - name: Install test dependencies
         run: sudo apt-get update -y && sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+
         id: cache-fuzz
         with:
           path: |
@@ -78,9 +92,9 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
             fuzz/target
             target
           key: cache-\${{ matrix.target }}-\${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
         with:
-          toolchain: '1.65.0'
+          toolchain: '1.74.0'
       - name: fuzz
         run: |
           if [[ "\${{ matrix.fuzz_target }}" =~ ^bitcoin ]]; then
@@ -89,7 +103,7 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
           echo "Using RUSTFLAGS \$RUSTFLAGS"
           cd fuzz && ./fuzz.sh "\${{ matrix.fuzz_target }}"
       - run: echo "\${{ matrix.fuzz_target }}" >executed_\${{ matrix.fuzz_target }}
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: executed_\${{ matrix.fuzz_target }}
           path: executed_\${{ matrix.fuzz_target }}
@@ -98,9 +112,13 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
     if: \${{ !github.event.act }}
     needs: fuzz
     runs-on: ubuntu-24.04
+    permissions:
+      contents: read
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
       - name: Display structure of downloaded files
         run: ls -R
       - run: find executed_* -type f -exec cat {} + | sort > executed
diff --git a/fuzz/src/fuzz_utils.rs b/fuzz/src/fuzz_utils.rs
index 8a072db98b..883729c3cd 100644
--- a/fuzz/src/fuzz_utils.rs
+++ b/fuzz/src/fuzz_utils.rs
@@ -35,3 +35,16 @@ pub fn consume_u64(data: &mut &[u8]) -> u64 {
         u64_bytes[7],
     ])
 }
+
+#[allow(dead_code)]
+pub fn consume_u32(data: &mut &[u8]) -> u32 {
+    // We need at least 4 bytes to read a u32
+    if data.len() < 4 {
+        return 0;
+    }
+
+    let (u32_bytes, rest) = data.split_at(4);
+    *data = rest;
+
+    u32::from_le_bytes([u32_bytes[0], u32_bytes[1], u32_bytes[2], u32_bytes[3]])
+}
diff --git a/fuzz/src/lib.rs b/fuzz/src/lib.rs
index 1be440fab2..3421bc2240 100644
--- a/fuzz/src/lib.rs
+++ b/fuzz/src/lib.rs
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Fuzzing
+//! Fuzzing
 
 pub mod fuzz_utils;
diff --git a/hashes/CHANGELOG.md b/hashes/CHANGELOG.md
index bd9aed7337..17e0d4eb6a 100644
--- a/hashes/CHANGELOG.md
+++ b/hashes/CHANGELOG.md
@@ -1,3 +1,22 @@
+# 0.18.0 - 2025-11-27
+
+* Add a dependency on the new `consensus_encoding` crate [#5181](https://github.com/rust-bitcoin/rust-bitcoin/pull/5181)
+
+# 0.17.0 - 2025-10-17
+
+* Bump MSRV from 1.63.0 to 1.74.0 for all crates in the repo [#4926](https://github.com/rust-bitcoin/rust-bitcoin/pull/4926)
+* Add a `sha3_256` module with `SHA3-256` [#4919](https://github.com/rust-bitcoin/rust-bitcoin/pull/4919)
+* Remove code deprecated in `v0.15.0` [#4840](https://github.com/rust-bitcoin/rust-bitcoin/pull/4840)
+* Update `serde` dependency to match workspace [#4321](https://github.com/rust-bitcoin/rust-bitcoin/pull/4321)
+* Remove `From<hash>` for not-general-hash types [#4128 ](https://github.com/rust-bitcoin/rust-bitcoin/pull/4128)
+* Remove the `GeneralHash` trait [#4085](https://github.com/rust-bitcoin/rust-bitcoin/pull/4085)
+* Only enable `hex`/`std`, and `hex`/`alloc` when `hex` is [#4055](https://github.com/rust-bitcoin/rust-bitcoin/pull/4055)
+* Derive `Debug` for all hash engines [#4015](https://github.com/rust-bitcoin/rust-bitcoin/pull/4015)
+* Add a tagged hash engine [#4010](https://github.com/rust-bitcoin/rust-bitcoin/pull/4010)
+* Add engine function to `siphash24::Hash` [#4003](https://github.com/rust-bitcoin/rust-bitcoin/pull/4003)
+* Do not implement `Default` for `HmacEngine` [#3981](https://github.com/rust-bitcoin/rust-bitcoin/pull/3981)
+* Invert dependency between `io` and `hashes` [#3961](https://github.com/rust-bitcoin/rust-bitcoin/pull/3961)
+
 # 0.16.0 - 2024-12-12
 
 * Make `hex-conservative` an optional dependency [#3611](https://github.com/rust-bitcoin/rust-bitcoin/pull/3611)
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index 99caab0b0b..358a44d74e 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin_hashes"
-version = "0.16.0"
+version = "0.18.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
@@ -10,7 +10,7 @@ categories = ["algorithms", "cryptography", "no-std"]
 keywords = [ "crypto", "bitcoin", "hash", "digest" ]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
@@ -22,16 +22,22 @@ serde = ["dep:serde", "hex"]
 small-hash = []
 
 [dependencies]
-internals = { package = "bitcoin-internals", path = "../internals" }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.1" }
+encoding = { package = "bitcoin-consensus-encoding", path = "../consensus_encoding", version = "=1.0.0-rc.2", default-features = false }
+
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
-serde = { version = "1.0.103", default-features = false, optional = true }
+serde = { version = "1.0.195", default-features = false, optional = true }
 
 [dev-dependencies]
-serde_test = "1.0"
+serde_test = "1.0.19"
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(hashes_fuzz)', 'cfg(rust_v_1_64)' ] }
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(hashes_fuzz)', 'cfg(rust_v_1_64)' ] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/hashes/README.md b/hashes/README.md
index 6052b3603a..3f6dfd8dd5 100644
--- a/hashes/README.md
+++ b/hashes/README.md
@@ -7,10 +7,6 @@ since these are needed to display hashes anyway.
 
 [Documentation](https://docs.rs/bitcoin_hashes/)
 
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
-
 ## Contributions
 
 Contributions are welcome, including additional hash function implementations.
diff --git a/hashes/contrib/extra_lints.sh b/hashes/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/hashes/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/hashes/embedded/Cargo.toml b/hashes/embedded/Cargo.toml
index 531c98b693..ef14668531 100644
--- a/hashes/embedded/Cargo.toml
+++ b/hashes/embedded/Cargo.toml
@@ -21,6 +21,9 @@ alloc-cortex-m = { version = "0.4.1", optional = true }
 bitcoin_hashes = { path="../", default-features = false, features = [] }
 bitcoin-io = { path = "../../io", default_features = false, features = ["hashes"] }
 
+[lints.clippy]
+use_self = "warn"
+
 [[bin]]
 name = "embedded"
 test = false
diff --git a/hashes/embedded/src/main.rs b/hashes/embedded/src/main.rs
index 3a19faaffd..ca36383ccf 100644
--- a/hashes/embedded/src/main.rs
+++ b/hashes/embedded/src/main.rs
@@ -5,10 +5,13 @@
 #[macro_use]
 extern crate bitcoin_hashes;
 
-#[cfg(feature = "alloc")] extern crate alloc;
-#[cfg(feature = "alloc")] use alloc_cortex_m::CortexMHeap;
-#[cfg(feature = "alloc")] use alloc::string::ToString;
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "alloc")]
+use alloc::string::ToString;
 
+#[cfg(feature = "alloc")]
+use alloc_cortex_m::CortexMHeap;
 use bitcoin_hashes::{sha256, HashEngine};
 use bitcoin_io::Write;
 use cortex_m_rt::entry;
@@ -37,7 +40,9 @@ const HEAP_SIZE: usize = 1024; // in bytes
 #[entry]
 fn main() -> ! {
     #[cfg(feature = "alloc")]
-    unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
+    unsafe {
+        ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE)
+    }
 
     let mut engine = sha256::Hash::engine();
     engine.write_all(b"abc").unwrap();
@@ -57,9 +62,9 @@ fn main() -> ! {
 fn check_result(engine: sha256::HashEngine) {
     let hash = TestType(sha256::Hash::from_engine(engine));
 
-    let hash_check =
-        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad".parse::<TestType>()
-            .unwrap();
+    let hash_check = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+        .parse::<TestType>()
+        .unwrap();
     hprintln!("hash:{} hash_check:{}", hash, hash_check).unwrap();
     if hash != hash_check {
         debug::exit(debug::EXIT_FAILURE);
diff --git a/hashes/src/cmp.rs b/hashes/src/cmp.rs
index 99ccea994a..3eeded7a8e 100644
--- a/hashes/src/cmp.rs
+++ b/hashes/src/cmp.rs
@@ -2,7 +2,7 @@
 
 //! Useful comparison functions.
 
-/// Compare two slices for equality in fixed time. Panics if the slices are of non-equal length.
+/// Compares two slices for equality in fixed time. Panics if the slices are of non-equal length.
 ///
 /// This works by XOR'ing each byte of the two inputs together and keeping an OR counter of the
 /// results.
@@ -102,68 +102,3 @@ mod tests {
         assert!(!fixed_time_eq(&[0b00000000, 0b00000000], &[0b00000001, 0b00000001]));
     }
 }
-
-#[cfg(bench)]
-#[cfg(feature = "hex")]
-mod benches {
-    use test::Bencher;
-
-    use crate::cmp::fixed_time_eq;
-    use crate::{sha256, sha512, Hash};
-
-    #[bench]
-    fn bench_32b_constant_time_cmp_ne(bh: &mut Bencher) {
-        let hash_a = sha256::Hash::hash(&[0; 1]);
-        let hash_b = sha256::Hash::hash(&[1; 1]);
-        bh.iter(|| fixed_time_eq(hash_a.as_byte_array(), hash_b.as_byte_array()))
-    }
-
-    #[bench]
-    fn bench_32b_slice_cmp_ne(bh: &mut Bencher) {
-        let hash_a = sha256::Hash::hash(&[0; 1]);
-        let hash_b = sha256::Hash::hash(&[1; 1]);
-        bh.iter(|| hash_a.as_byte_array() == hash_b.as_byte_array())
-    }
-
-    #[bench]
-    fn bench_32b_constant_time_cmp_eq(bh: &mut Bencher) {
-        let hash_a = sha256::Hash::hash(&[0; 1]);
-        let hash_b = sha256::Hash::hash(&[0; 1]);
-        bh.iter(|| fixed_time_eq(hash_a.as_byte_array(), hash_b.as_byte_array()))
-    }
-
-    #[bench]
-    fn bench_32b_slice_cmp_eq(bh: &mut Bencher) {
-        let hash_a = sha256::Hash::hash(&[0; 1]);
-        let hash_b = sha256::Hash::hash(&[0; 1]);
-        bh.iter(|| hash_a.as_byte_array() == hash_b.as_byte_array())
-    }
-
-    #[bench]
-    fn bench_64b_constant_time_cmp_ne(bh: &mut Bencher) {
-        let hash_a = sha512::Hash::hash(&[0; 1]);
-        let hash_b = sha512::Hash::hash(&[1; 1]);
-        bh.iter(|| fixed_time_eq(hash_a.as_byte_array(), hash_b.as_byte_array()))
-    }
-
-    #[bench]
-    fn bench_64b_slice_cmp_ne(bh: &mut Bencher) {
-        let hash_a = sha512::Hash::hash(&[0; 1]);
-        let hash_b = sha512::Hash::hash(&[1; 1]);
-        bh.iter(|| hash_a.as_byte_array() == hash_b.as_byte_array())
-    }
-
-    #[bench]
-    fn bench_64b_constant_time_cmp_eq(bh: &mut Bencher) {
-        let hash_a = sha512::Hash::hash(&[0; 1]);
-        let hash_b = sha512::Hash::hash(&[0; 1]);
-        bh.iter(|| fixed_time_eq(hash_a.as_byte_array(), hash_b.as_byte_array()))
-    }
-
-    #[bench]
-    fn bench_64b_slice_cmp_eq(bh: &mut Bencher) {
-        let hash_a = sha512::Hash::hash(&[0; 1]);
-        let hash_b = sha512::Hash::hash(&[0; 1]);
-        bh.iter(|| hash_a.as_byte_array() == hash_b.as_byte_array())
-    }
-}
diff --git a/hashes/src/error.rs b/hashes/src/error.rs
deleted file mode 100644
index ce2c82af2d..0000000000
--- a/hashes/src/error.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Error code for the `hashes` crate.
-
-use core::convert::Infallible;
-use core::fmt;
-
-/// Attempted to create a hash from an invalid length slice.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FromSliceError(pub(crate) FromSliceErrorInner);
-
-impl From<Infallible> for FromSliceError {
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl FromSliceError {
-    /// Returns the expected slice length.
-    pub fn expected_length(&self) -> usize { self.0.expected }
-
-    /// Returns the invalid slice length.
-    pub fn invalid_length(&self) -> usize { self.0.got }
-}
-
-/// Attempted to create a hash from an invalid length slice.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FromSliceErrorInner {
-    pub(crate) expected: usize,
-    pub(crate) got: usize,
-}
-
-impl From<Infallible> for FromSliceErrorInner {
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl fmt::Display for FromSliceError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "invalid slice length {} (expected {})", self.0.got, self.0.expected)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for FromSliceError {}
diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index fbb11e1d03..499c666674 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -23,7 +23,7 @@ impl Hash {
 
         let mut ret = [0; 20];
         ret.copy_from_slice(rmd.as_byte_array());
-        Hash(ret)
+        Self(ret)
     }
 }
 
@@ -130,40 +130,3 @@ mod tests {
         assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{hash160, Hash as _, HashEngine};
-
-    #[bench]
-    pub fn hash160_10(bh: &mut Bencher) {
-        let mut engine = hash160::Hash::engine();
-        let bytes = [1u8; 10];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn hash160_1k(bh: &mut Bencher) {
-        let mut engine = hash160::Hash::engine();
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn hash160_64k(bh: &mut Bencher) {
-        let mut engine = hash160::Hash::engine();
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/src/hkdf/mod.rs b/hashes/src/hkdf/mod.rs
index c381422da4..8d852d1a37 100644
--- a/hashes/src/hkdf/mod.rs
+++ b/hashes/src/hkdf/mod.rs
@@ -3,7 +3,7 @@
 //! HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
 //!
 //! Implementation based on RFC5869, but the interface is scoped
-//! to BIP324's requirements.
+//! to BIP-0324's requirements.
 
 #[cfg(feature = "alloc")]
 use alloc::vec;
@@ -42,7 +42,7 @@ impl<T: HashEngine> Hkdf<T>
 where
     T: Default,
 {
-    /// Initialize a HKDF by performing the extract step.
+    /// Initializes a HKDF by performing the extract step.
     pub fn new(salt: &[u8], ikm: &[u8]) -> Self {
         let mut engine: HmacEngine<T> = HmacEngine::new(salt);
         engine.input(ikm);
@@ -62,7 +62,7 @@ where
         // Counter starts at "1" based on RFC5869 spec and is committed to in the hash.
         let mut counter = 1u8;
         // Ceiling calculation for the total number of blocks (iterations) required for the expand.
-        let total_blocks = (okm.len() + T::Bytes::LEN - 1) / T::Bytes::LEN;
+        let total_blocks = okm.len().div_ceil(T::Bytes::LEN);
 
         while counter <= total_blocks as u8 {
             let mut engine: HmacEngine<T> = HmacEngine::new(self.prk.as_ref());
diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index aebe2e60e3..dc96379f76 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -22,7 +22,7 @@ pub struct Hmac<T: Hash>(T);
 
 impl<T: Hash + str::FromStr> str::FromStr for Hmac<T> {
     type Err = <T as str::FromStr>::Err;
-    fn from_str(s: &str) -> Result<Self, Self::Err> { Ok(Hmac(str::FromStr::from_str(s)?)) }
+    fn from_str(s: &str) -> Result<Self, Self::Err> { Ok(Self(str::FromStr::from_str(s)?)) }
 }
 
 impl<T: Hash> PartialEq for Hmac<T> {
@@ -46,7 +46,7 @@ impl<T: HashEngine> HmacEngine<T> {
     /// # Panics
     ///
     /// Larger hashes will result in a panic.
-    pub fn new(key: &[u8]) -> HmacEngine<T>
+    pub fn new(key: &[u8]) -> Self
     where
         T: Default,
     {
@@ -54,7 +54,7 @@ impl<T: HashEngine> HmacEngine<T> {
 
         let mut ipad = [0x36u8; 128];
         let mut opad = [0x5cu8; 128];
-        let mut ret = HmacEngine { iengine: T::default(), oengine: T::default() };
+        let mut ret = Self { iengine: T::default(), oengine: T::default() };
 
         if key.len() > T::BLOCK_SIZE {
             let mut engine = T::default();
@@ -82,9 +82,7 @@ impl<T: HashEngine> HmacEngine<T> {
     }
 
     /// A special constructor giving direct access to the underlying "inner" and "outer" engines.
-    pub fn from_inner_engines(iengine: T, oengine: T) -> HmacEngine<T> {
-        HmacEngine { iengine, oengine }
-    }
+    pub fn from_inner_engines(iengine: T, oengine: T) -> Self { Self { iengine, oengine } }
 }
 
 impl<T: HashEngine> HashEngine for HmacEngine<T> {
@@ -121,12 +119,7 @@ impl<T: Hash> convert::AsRef<[u8]> for Hmac<T> {
 impl<T: Hash> Hash for Hmac<T> {
     type Bytes = T::Bytes;
 
-    fn from_byte_array(bytes: T::Bytes) -> Self { Hmac(T::from_byte_array(bytes)) }
-
-    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-    fn from_slice(sl: &[u8]) -> Result<Hmac<T>, crate::FromSliceError> {
-        T::from_slice(sl).map(Hmac)
-    }
+    fn from_byte_array(bytes: T::Bytes) -> Self { Self(T::from_byte_array(bytes)) }
 
     fn to_byte_array(self) -> Self::Bytes { self.0.to_byte_array() }
 
@@ -142,9 +135,9 @@ impl<T: Hash + Serialize> Serialize for Hmac<T> {
 
 #[cfg(feature = "serde")]
 impl<'de, T: Hash + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Hmac<T>, D::Error> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
         let bytes = Deserialize::deserialize(d)?;
-        Ok(Hmac(bytes))
+        Ok(Self(bytes))
     }
 }
 
@@ -316,40 +309,3 @@ mod tests {
         );
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{sha256, HashEngine as _, HmacEngine};
-
-    #[bench]
-    pub fn hmac_sha256_10(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
-        let bytes = [1u8; 10];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn hmac_sha256_1k(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn hmac_sha256_64k(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index f3d2cecfb9..1f6a8a0df4 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -8,14 +8,14 @@
 ///
 /// # Parameters
 ///
-/// * `$bits` - number of bits this hash type has
+/// * `$bits` - the number of bits this hash type has
 /// * `$reverse` - `bool`  - `true` if the hash type should be displayed backwards, `false`
 ///   otherwise.
-/// * `$gen: $gent` - generic type(s) and trait bound(s)
+/// * `$gen: $gent` - the generic type(s) and trait bound(s)
 ///
 /// Restrictions on usage:
 ///
-/// * The hash type must implement the `GeneralHash` trait.
+/// * The `Hash` type in scope must provide `from_byte_array`, `to_byte_array`, and `as_byte_array` (e.g., via `hash_type_no_default!`).
 macro_rules! hash_trait_impls {
     ($bits:expr, $reverse:expr $(, $gen:ident: $gent:ident)*) => {
         $crate::impl_bytelike_traits!(Hash, { $bits / 8 } $(, $gen: $gent)*);
@@ -34,12 +34,6 @@ macro_rules! hash_trait_impls {
 
             fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) }
 
-            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-            #[allow(deprecated)]           // Because of `from_slice`.
-            fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<Hash<$($gen),*>, $crate::FromSliceError> {
-                Self::from_slice(sl)
-            }
-
             fn to_byte_array(self) -> Self::Bytes { self.to_byte_array() }
 
             fn as_byte_array(&self) -> &Self::Bytes { self.as_byte_array() }
@@ -48,7 +42,7 @@ macro_rules! hash_trait_impls {
 }
 pub(crate) use hash_trait_impls;
 
-/// Creates a type called `Hash` and implements the standard general hashing interface for it.
+/// Constructs a type called `Hash` and implements the standard general hashing interface for it.
 ///
 /// The created type has a single field and will have all standard derives as well as an
 /// implementation of [`crate::Hash`].
@@ -57,11 +51,11 @@ pub(crate) use hash_trait_impls;
 ///
 /// * `$bits` - the number of bits of the hash type
 /// * `$reverse` - `true` if the hash should be displayed backwards, `false` otherwise
-/// * `$doc` - doc string to put on the type
+/// * `$doc` - the doc string to put on the type
 ///
 /// Restrictions on usage:
 ///
-/// * The hash type must implement the `GeneralHash` trait.
+/// * Requires a `HashEngine` type in this module implementing `Default` and `crate::HashEngine<Hash = Hash, Bytes = [u8; $bits / 8]>`.
 macro_rules! general_hash_type {
     ($bits:expr, $reverse:expr, $doc:literal) => {
         /// Hashes some bytes.
@@ -133,24 +127,6 @@ macro_rules! hash_type_no_default {
             /// Constructs a new hash from the underlying byte array.
             pub const fn from_byte_array(bytes: [u8; $bits / 8]) -> Self { Hash(bytes) }
 
-            /// Copies a byte slice into a hash object.
-            #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
-            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-            pub fn from_slice(
-                sl: &[u8],
-            ) -> $crate::_export::_core::result::Result<Hash, $crate::FromSliceError> {
-                if sl.len() != $bits / 8 {
-                    Err($crate::error::FromSliceError($crate::error::FromSliceErrorInner {
-                        expected: $bits / 8,
-                        got: sl.len(),
-                    }))
-                } else {
-                    let mut ret = [0; $bits / 8];
-                    ret.copy_from_slice(sl);
-                    Ok(Self::from_byte_array(ret))
-                }
-            }
-
             /// Returns the underlying byte array.
             pub const fn to_byte_array(self) -> [u8; $bits / 8] { self.0 }
 
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 3e8c41a6db..1ec86ffdcf 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin Hashes Library
+//! Rust Bitcoin Hashes Library
 //!
 //! This library implements the hash functions needed by Bitcoin. As an ancillary thing, it exposes
 //! hexadecimal serialization and deserialization, since these are needed to display hashes.
@@ -51,9 +51,6 @@
 //! ```
 
 #![no_std]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![cfg_attr(bench, feature(test))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
@@ -62,11 +59,10 @@
 #![warn(clippy::return_self_not_must_use)]
 // Instead of littering the codebase for non-fuzzing and bench code just globally allow.
 #![cfg_attr(hashes_fuzz, allow(dead_code, unused_imports))]
-#![cfg_attr(bench, allow(dead_code, unused_imports))]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -82,8 +78,6 @@ pub extern crate serde;
 
 #[cfg(all(test, feature = "serde"))]
 extern crate serde_test;
-#[cfg(bench)]
-extern crate test;
 
 /// Re-export the `hex-conservative` crate.
 #[cfg(feature = "hex")]
@@ -97,8 +91,6 @@ pub mod _export {
     }
 }
 
-#[deprecated(since = "TBD", note = "unused now that `Hash::from_slice` is deprecated")]
-mod error;
 mod internal_macros;
 
 pub mod cmp;
@@ -113,24 +105,16 @@ pub mod sha256;
 pub mod sha256d;
 pub mod sha256t;
 pub mod sha384;
+pub mod sha3_256;
 pub mod sha512;
 pub mod sha512_256;
 pub mod siphash24;
 
-#[deprecated(since = "0.15.0", note = "use crate::macros instead")]
-pub mod serde_macros {
-    //! Macros for serde trait implementations, and supporting code.
-
-    #[cfg(feature = "serde")]
-    pub mod serde_details {
-        //! Functions used by serde impls of all hashes.
-        pub use crate::macros::serde_details::*;
-    }
-}
-
 use core::fmt::{self, Write as _};
 use core::{convert, hash};
 
+use encoding::Encoder;
+
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
@@ -155,6 +139,8 @@ pub use sha256d::Hash as Sha256d;
 /// SHA-384: Alias for the [`sha384::Hash`] hash type.
 #[doc(inline)]
 pub use sha384::Hash as Sha384;
+/// SHA3-256: Alias for the [`sha3_256::Hash`] hash type.
+pub use sha3_256::Hash as Sha3_256;
 /// SHA-512: Alias for the [`sha512::Hash`] hash type.
 #[doc(inline)]
 pub use sha512::Hash as Sha512;
@@ -165,11 +151,6 @@ pub use sha512_256::Hash as Sha512_256;
 #[doc(inline)]
 pub use siphash24::Hash as Siphash24;
 
-/// Attempted to create a hash from an invalid length slice.
-#[deprecated(since = "TBD", note = "unused now that `Hash::from_slice` is deprecated")]
-#[allow(deprecated_in_future)]
-pub type FromSliceError = crate::error::FromSliceError; // Alias instead of re-export so we can deprecate it.
-
 /// Tagged SHA-256: Type alias for the [`sha256t::Hash`] hash type.
 pub type Sha256t<T> = sha256t::Hash<T>;
 
@@ -199,16 +180,35 @@ pub trait HashEngine: Clone {
     /// Length of the hash's internal block size, in bytes.
     const BLOCK_SIZE: usize;
 
-    /// Add data to the hash engine.
+    /// Adds data to the hash engine.
     fn input(&mut self, data: &[u8]);
 
-    /// Return the number of bytes already input into the engine.
+    /// Returns the number of bytes already input into the engine.
     fn n_bytes_hashed(&self) -> u64;
 
     /// Finalizes this engine.
     fn finalize(self) -> Self::Hash;
 }
 
+/// Encodes an object into a hash engine.
+///
+/// Consumes and returns the hash engine to make it easier to call
+/// [`HashEngine::finalize`] directly on the result.
+pub fn encode_to_engine<T, H>(object: &T, mut engine: H) -> H
+where
+    T: encoding::Encodable + ?Sized,
+    H: HashEngine,
+{
+    let mut encoder = object.encoder();
+    loop {
+        engine.input(encoder.current_chunk());
+        if !encoder.advance() {
+            break;
+        }
+    }
+    engine
+}
+
 /// Trait which applies to hashes of all types.
 pub trait Hash:
     Copy + Clone + PartialEq + Eq + PartialOrd + Ord + hash::Hash + convert::AsRef<[u8]>
@@ -227,11 +227,6 @@ pub trait Hash:
     /// Constructs a new hash from the underlying byte array.
     fn from_byte_array(bytes: Self::Bytes) -> Self;
 
-    /// Copies a byte slice into a hash object.
-    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-    #[deprecated(since = "TBD", note = "use `from_byte_array` instead")]
-    fn from_slice(sl: &[u8]) -> Result<Self, FromSliceError>;
-
     /// Returns the underlying byte array.
     fn to_byte_array(self) -> Self::Bytes;
 
@@ -280,7 +275,6 @@ pub fn debug_hex(bytes: &[u8], f: &mut fmt::Formatter) -> fmt::Result {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::sha256d;
 
     hash_newtype! {
@@ -312,7 +306,7 @@ mod tests {
 
         let orig = DUMMY;
         let hex = format!("{}", orig);
-        let rinsed = hex.parse::<TestNewtype>().expect("failed to parse hex");
-        assert_eq!(rinsed, orig)
+        let roundtrip = hex.parse::<TestNewtype>().expect("failed to parse hex");
+        assert_eq!(roundtrip, orig)
     }
 }
diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 162af9a032..bb530b7f8b 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -23,7 +23,7 @@
 /// ```
 ///
 /// The `hash_str` marker says the midstate should be generated by hashing the supplied string in a
-/// way described in BIP-341. Alternatively, you can supply `hash_bytes` to hash raw bytes. If you
+/// way described in BIP-0341. Alternatively, you can supply `hash_bytes` to hash raw bytes. If you
 /// have the midstate already pre-computed and prefer **compiler** performance to readability you
 /// may use `raw(MIDSTATE_BYTES, HASHED_BYTES_LENGTH)` instead, note that HASHED_BYTES_LENGTH must
 /// be a multiple of 64.
@@ -38,7 +38,7 @@ macro_rules! sha256t_tag {
     }
 }
 
-/// Creates a new newtype around a [`Hash`] type.
+/// Constructs a new newtype around a [`Hash`] type.
 ///
 /// The syntax is similar to the usual tuple struct syntax:
 ///
@@ -67,7 +67,7 @@ macro_rules! sha256t_tag {
 /// This will display the hash backwards regardless of what the inner type does. Use `forward`
 /// instead of `backward` to force displaying forward.
 ///
-/// You can add arbitrary doc comments or other attributes to the struct or it's field. Note that
+/// You can add arbitrary doc comments or other attributes to the struct or its field. Note that
 /// the macro already derives [`Copy`], [`Clone`], [`Eq`], [`PartialEq`],
 /// [`Hash`](core::hash::Hash), [`Ord`], [`PartialOrd`].
 ///
@@ -96,7 +96,7 @@ macro_rules! sha256t_tag {
 // one. The following code is written the way it is for some specific reasons. If you think you can
 // simplify it, I suggest spending your time elsewhere.
 //
-// If you looks at the code carefully you might ask these questions:
+// If you look at the code carefully you might ask these questions:
 //
 // * Why are attributes using `tt` and not `meta`?!
 // * Why are the macros split like that?!
@@ -139,14 +139,6 @@ macro_rules! hash_newtype {
                 $newtype(<$hash>::from_byte_array(bytes))
             }
 
-            /// Copies a byte slice into a hash object.
-            #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
-            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-            #[allow(deprecated)]           // Because of `from_slice`.
-            pub fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> {
-                Ok($newtype(<$hash as $crate::Hash>::from_slice(sl)?))
-            }
-
             /// Returns the underlying byte array.
             pub const fn to_byte_array(self) -> <$hash as $crate::Hash>::Bytes {
                 self.0.to_byte_array()
@@ -165,13 +157,6 @@ macro_rules! hash_newtype {
 
             fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) }
 
-            #[inline]
-            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-            #[allow(deprecated)]           // Because of `from_slice`.
-            fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> {
-                Self::from_slice(sl)
-            }
-
             fn to_byte_array(self) -> Self::Bytes { self.to_byte_array() }
 
             fn as_byte_array(&self) -> &Self::Bytes { self.as_byte_array() }
@@ -220,9 +205,9 @@ macro_rules! impl_debug_only_for_newtype {
 ///
 /// # Parameters
 ///
-/// * `ty` - The bytelike type to implement the traits on.
-/// * `$len` - The number of bytes this type has.
-/// * `$gen: $gent` - generic type(s) and trait bound(s).
+/// * `ty` - the bytelike type to implement the traits on.
+/// * `$len` - the number of bytes this type has.
+/// * `$gen: $gent` - the generic type(s) and trait bound(s).
 #[doc(hidden)]
 #[macro_export]
 macro_rules! impl_bytelike_traits {
@@ -356,7 +341,7 @@ macro_rules! hash_newtype_struct {
 // duplicates/conflicts and report an error.
 //
 // FYI, no, we can't use a helper macro to first filter all `hash_newtype` attributes. We would be
-// attempting to match on macros instead. So we must write `hashe_newtype` in each branch.
+// attempting to match on macros instead. So we must write `hash_newtype` in each branch.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! hash_newtype_get_direction {
@@ -506,7 +491,7 @@ macro_rules! serde_impl(
 
         impl<'de $(, $gen: $gent)*> $crate::serde::Deserialize<'de> for $t<$($gen),*> {
             fn deserialize<D: $crate::serde::Deserializer<'de>>(d: D) -> core::result::Result<$t<$($gen),*>, D::Error> {
-                use $crate::serde_macros::serde_details::{BytesVisitor, HexVisitor};
+                use $crate::macros::serde_details::{BytesVisitor, HexVisitor};
 
                 if d.is_human_readable() {
                     d.deserialize_str(HexVisitor::<Self>::default())
diff --git a/hashes/src/ripemd160/crypto.rs b/hashes/src/ripemd160/crypto.rs
index 70e92f66d6..115974f204 100644
--- a/hashes/src/ripemd160/crypto.rs
+++ b/hashes/src/ripemd160/crypto.rs
@@ -99,7 +99,7 @@ macro_rules! process_block(
                   $data[$pdata_index1], $pbits1, 0x50a28be6,
                   bbb[$pj1] ^ (bbb[$pj2] | !bbb[$pj3])); )*
 
-        // Porallel Round 2
+        // Parallel Round 2
         $( round!(bbb[$pi0], bbb[$pi1], bbb[$pi2], bbb[$pi3], bbb[$pi4],
                   $data[$pdata_index2], $pbits2, 0x5c4dd124,
                   (bbb[$pi1] & bbb[$pi3]) | (bbb[$pi2] & !bbb[$pi3])); )*
@@ -229,7 +229,7 @@ impl HashEngine {
             round5: h_ordering 2, 3, 4, 0, 1; data_index 15; roll_shift  5;
             round5: h_ordering 1, 2, 3, 4, 0; data_index 13; roll_shift  6;
 
-            // Porallel Round 1;
+            // Parallel Round 1;
             par_round1: h_ordering 0, 1, 2, 3, 4; data_index  5; roll_shift  8;
             par_round1: h_ordering 4, 0, 1, 2, 3; data_index 14; roll_shift  9;
             par_round1: h_ordering 3, 4, 0, 1, 2; data_index  7; roll_shift  9;
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index 36f2b24169..e130eedb81 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -3,11 +3,8 @@
 //! RIPEMD160 implementation.
 
 use internals::slice::SliceExt;
-
-#[cfg(bench)]
-mod benches;
 mod crypto;
-#[cfg(bench)]
+#[cfg(test)]
 mod tests;
 
 use core::cmp;
@@ -39,7 +36,7 @@ impl Hash {
         e.input(&(8 * n_bytes_hashed).to_le_bytes());
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
-        Hash(e.midstate())
+        Self(e.midstate())
     }
 
     /// Finalize a hash engine to produce a hash.
@@ -62,7 +59,7 @@ pub struct HashEngine {
 }
 
 impl HashEngine {
-    /// Constructs a new SHA256 hash engine.
+    /// Constructs a new RIPEMD160 hash engine.
     pub const fn new() -> Self {
         Self {
             h: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0],
diff --git a/hashes/src/ripemd160/tests.rs b/hashes/src/ripemd160/tests.rs
index 3b9a324b68..8eb9061af1 100644
--- a/hashes/src/ripemd160/tests.rs
+++ b/hashes/src/ripemd160/tests.rs
@@ -100,7 +100,7 @@ fn ripemd_serde() {
         0xf1, 0x4a, 0xca, 0xd7,
     ];
 
-    let hash = ripemd160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+    let hash = ripemd160::Hash::from_byte_array(HASH_BYTES);
     assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
     assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
 }
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index ca5e92acb8..c2a8aecc15 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -3,11 +3,8 @@
 //! SHA1 implementation.
 
 use internals::slice::SliceExt;
-
-#[cfg(bench)]
-mod benches;
 mod crypto;
-#[cfg(bench)]
+#[cfg(test)]
 mod tests;
 
 use core::cmp;
@@ -38,7 +35,7 @@ impl Hash {
         e.input(&(8 * n_bytes_hashed).to_be_bytes());
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
-        Hash(e.midstate())
+        Self(e.midstate())
     }
 }
 
diff --git a/hashes/src/sha1/tests.rs b/hashes/src/sha1/tests.rs
index ce30cd3342..831457ac2b 100644
--- a/hashes/src/sha1/tests.rs
+++ b/hashes/src/sha1/tests.rs
@@ -85,7 +85,7 @@ fn sha1_serde() {
         0xf1, 0x4a, 0xca, 0xd7,
     ];
 
-    let hash = sha1::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+    let hash = sha1::Hash::from_byte_array(HASH_BYTES);
     assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
     assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
 }
diff --git a/hashes/src/sha256/crypto.rs b/hashes/src/sha256/crypto.rs
index ef4b0f25ce..905a584880 100644
--- a/hashes/src/sha256/crypto.rs
+++ b/hashes/src/sha256/crypto.rs
@@ -110,7 +110,7 @@ impl Midstate {
             0x5be0cd19,
         ];
 
-        let num_chunks = (bytes.len() + 9 + 63) / 64;
+        let num_chunks = (bytes.len() + 9).div_ceil(64);
         let mut chunk = 0;
         #[allow(clippy::precedence)]
         while chunk < num_chunks {
@@ -243,7 +243,7 @@ impl Midstate {
             output[i * 4 + 3] = (state[i + 0] >> 0) as u8;
             i += 1;
         }
-        Midstate { bytes: output, bytes_hashed: bytes.len() as u64 }
+        Self { bytes: output, bytes_hashed: bytes.len() as u64 }
     }
 }
 
@@ -292,8 +292,8 @@ impl HashEngine {
         // Load initial values
         // CAST SAFETY: loadu_si128 documentation states that mem_addr does not
         // need to be aligned on any particular boundary.
-        tmp = _mm_loadu_si128(self.h.as_ptr().add(0) as *const __m128i);
-        state1 = _mm_loadu_si128(self.h.as_ptr().add(4) as *const __m128i);
+        tmp = _mm_loadu_si128(self.h.as_ptr().add(0).cast::<__m128i>());
+        state1 = _mm_loadu_si128(self.h.as_ptr().add(4).cast::<__m128i>());
 
         tmp = _mm_shuffle_epi32(tmp, 0xB1); // CDAB
         state1 = _mm_shuffle_epi32(state1, 0x1B); // EFGH
@@ -307,7 +307,7 @@ impl HashEngine {
             cdgh_save = state1;
 
             // Rounds 0-3
-            msg = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset) as *const __m128i);
+            msg = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset).cast::<__m128i>());
             msg0 = _mm_shuffle_epi8(msg, MASK);
             msg = _mm_add_epi32(
                 msg0,
@@ -318,7 +318,7 @@ impl HashEngine {
             state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
 
             // Rounds 4-7
-            msg1 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 16) as *const __m128i);
+            msg1 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 16).cast::<__m128i>());
             msg1 = _mm_shuffle_epi8(msg1, MASK);
             msg = _mm_add_epi32(
                 msg1,
@@ -330,7 +330,7 @@ impl HashEngine {
             msg0 = _mm_sha256msg1_epu32(msg0, msg1);
 
             // Rounds 8-11
-            msg2 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 32) as *const __m128i);
+            msg2 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 32).cast::<__m128i>());
             msg2 = _mm_shuffle_epi8(msg2, MASK);
             msg = _mm_add_epi32(
                 msg2,
@@ -342,7 +342,7 @@ impl HashEngine {
             msg1 = _mm_sha256msg1_epu32(msg1, msg2);
 
             // Rounds 12-15
-            msg3 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 48) as *const __m128i);
+            msg3 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 48).cast::<__m128i>());
             msg3 = _mm_shuffle_epi8(msg3, MASK);
             msg = _mm_add_epi32(
                 msg3,
@@ -519,8 +519,8 @@ impl HashEngine {
         // Save state
         // CAST SAFETY: storeu_si128 documentation states that mem_addr does not
         // need to be aligned on any particular boundary.
-        _mm_storeu_si128(self.h.as_mut_ptr().add(0) as *mut __m128i, state0);
-        _mm_storeu_si128(self.h.as_mut_ptr().add(4) as *mut __m128i, state1);
+        _mm_storeu_si128(self.h.as_mut_ptr().add(0).cast::<__m128i>(), state0);
+        _mm_storeu_si128(self.h.as_mut_ptr().add(4).cast::<__m128i>(), state1);
     }
 
     // Algorithm copied from libsecp256k1
@@ -608,6 +608,7 @@ impl HashEngine {
         round!(d, e, f, g, h, a, b, c, 0xa4506ceb, w[13], w[11], w[6], w[14]);
         round!(c, d, e, f, g, h, a, b, 0xbef9a3f7, w[14], w[12], w[7], w[15]);
         round!(b, c, d, e, f, g, h, a, 0xc67178f2, w[15], w[13], w[8], w[0]);
+        let _ = w[15]; // silence "unnecessary assignment" lint in macro
 
         self.h[0] = self.h[0].wrapping_add(a);
         self.h[1] = self.h[1].wrapping_add(b);
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 39c3257be6..6633c6737d 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -2,10 +2,8 @@
 
 //! SHA256 implementation.
 
-#[cfg(bench)]
-mod benches;
 mod crypto;
-#[cfg(bench)]
+#[cfg(test)]
 mod tests;
 
 use core::{cmp, convert, fmt};
@@ -48,14 +46,14 @@ impl HashEngine {
     /// Constructs a new [`HashEngine`] from a [`Midstate`].
     ///
     /// Please see docs on [`Midstate`] before using this function.
-    pub fn from_midstate(midstate: Midstate) -> HashEngine {
+    pub fn from_midstate(midstate: Midstate) -> Self {
         let mut ret = [0; 8];
         for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0)
         {
             *ret_val = u32::from_be_bytes(*midstate_bytes);
         }
 
-        HashEngine { buffer: [0; BLOCK_SIZE], h: ret, bytes_hashed: midstate.bytes_hashed }
+        Self { buffer: [0; BLOCK_SIZE], h: ret, bytes_hashed: midstate.bytes_hashed }
     }
 
     /// Returns `true` if the midstate can be extracted from this engine.
@@ -128,7 +126,7 @@ impl Hash {
         e.input(&(8 * n_bytes_hashed).to_be_bytes());
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
-        Hash(e.midstate_unchecked().bytes)
+        Self(e.midstate_unchecked().bytes)
     }
 
     /// Finalize a hash engine to obtain a hash.
@@ -147,17 +145,11 @@ impl Hash {
     #[must_use]
     pub fn hash_again(&self) -> sha256d::Hash { sha256d::Hash::from_byte_array(hash(&self.0).0) }
 
-    /// Computes hash from `bytes` in `const` context.
-    ///
-    /// Warning: this function is inefficient. It should be only used in `const` context.
-    #[deprecated(since = "0.15.0", note = "use `Self::hash_unoptimized` instead")]
-    pub const fn const_hash(bytes: &[u8]) -> Self { Hash::hash_unoptimized(bytes) }
-
     /// Computes hash from `bytes` in `const` context.
     ///
     /// Warning: this function is inefficient. It should be only used in `const` context.
     pub const fn hash_unoptimized(bytes: &[u8]) -> Self {
-        Hash(Midstate::compute_midstate_unoptimized(bytes, true).bytes)
+        Self(Midstate::compute_midstate_unoptimized(bytes, true).bytes)
     }
 }
 
@@ -169,11 +161,11 @@ impl Hash {
 /// It represents "partially hashed data" but does not itself have properties of cryptographic
 /// hashes. For example, when (ab)used as hashes, midstates are vulnerable to trivial
 /// length-extension attacks. They are typically used to optimize the computation of full hashes.
-/// For example, when implementing BIP-340 tagged hashes, which always begin by hashing the same
+/// For example, when implementing BIP-0340 tagged hashes, which always begin by hashing the same
 /// fixed 64-byte prefix, it makes sense to hash the prefix once, store the midstate as a constant,
 /// and hash any future data starting from the constant rather than from a fresh hash engine.
 ///
-/// For BIP-340 support we provide the [`sha256t`] module, and the [`sha256t_tag`] macro which will
+/// For BIP-0340 support we provide the [`sha256t`] module, and the [`sha256t_tag`] macro which will
 /// create the midstate for you in const context.
 #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Midstate {
@@ -185,7 +177,7 @@ pub struct Midstate {
 }
 
 impl Midstate {
-    /// Construct a new [`Midstate`] from the `state` and the `bytes_hashed` to get to that state.
+    /// Constructs a new [`Midstate`] from the `state` and the `bytes_hashed` to get to that state.
     ///
     /// # Panics
     ///
@@ -195,7 +187,7 @@ impl Midstate {
             panic!("bytes hashed is not a multiple of 64");
         }
 
-        Midstate { bytes: state, bytes_hashed }
+        Self { bytes: state, bytes_hashed }
     }
 
     /// Deconstructs the [`Midstate`], returning the underlying byte array and number of bytes hashed.
diff --git a/hashes/src/sha256/tests.rs b/hashes/src/sha256/tests.rs
index 4e45ae6545..b320969eb9 100644
--- a/hashes/src/sha256/tests.rs
+++ b/hashes/src/sha256/tests.rs
@@ -77,13 +77,13 @@ fn fmt_roundtrips() {
 
     let hash = sha256::Hash::hash(b"some arbitrary bytes");
     let hex = format!("{}", hash);
-    let rinsed = hex.parse::<sha256::Hash>().expect("failed to parse hex");
-    assert_eq!(rinsed, hash)
+    let roundtrip = hex.parse::<sha256::Hash>().expect("failed to parse hex");
+    assert_eq!(roundtrip, hash)
 }
 
 #[test]
 #[rustfmt::skip]
-pub(crate) fn midstate() {
+fn midstate() {
     // Test vector obtained by doing an asset issuance on Elements
     let mut engine = sha256::Hash::engine();
     // sha256dhash of outpoint
@@ -178,6 +178,7 @@ fn hash_unoptimized() {
 }
 
 // The midstate of an empty hash engine tagged with "TapLeaf".
+#[cfg(feature = "alloc")]
 const TAP_LEAF_MIDSTATE: Midstate = Midstate::new(
     [
         156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243, 147,
@@ -186,9 +187,6 @@ const TAP_LEAF_MIDSTATE: Midstate = Midstate::new(
     64,
 );
 
-#[test]
-fn const_midstate() { assert_eq!(Midstate::hash_tag(b"TapLeaf"), TAP_LEAF_MIDSTATE,) }
-
 #[test]
 #[cfg(feature = "alloc")]
 fn regression_midstate_debug_format() {
@@ -212,7 +210,7 @@ fn sha256_serde() {
         0xb7, 0x65, 0x44, 0x8c, 0x86, 0x35, 0xfb, 0x6c,
     ];
 
-    let hash = sha256::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+    let hash = sha256::Hash::from_byte_array(HASH_BYTES);
     assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
     assert_tokens(
         &hash.readable(),
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index add1935e18..f964977103 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -18,7 +18,7 @@ impl Hash {
 
         let mut ret = [0; 32];
         ret.copy_from_slice(sha2d.as_byte_array());
-        Hash(ret)
+        Self(ret)
     }
 }
 
@@ -112,8 +112,8 @@ mod tests {
 
         let hash = sha256d::Hash::hash(b"some arbitrary bytes");
         let hex = format!("{}", hash);
-        let rinsed = hex.parse::<sha256d::Hash>().expect("failed to parse hex");
-        assert_eq!(rinsed, hash)
+        let roundtrip = hex.parse::<sha256d::Hash>().expect("failed to parse hex");
+        assert_eq!(roundtrip, hash)
     }
 
     #[test]
@@ -137,40 +137,3 @@ mod tests {
         );
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{sha256d, Hash, HashEngine};
-
-    #[bench]
-    pub fn sha256d_10(bh: &mut Bencher) {
-        let mut engine = sha256d::Hash::engine();
-        let bytes = [1u8; 10];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha256d_1k(bh: &mut Bencher) {
-        let mut engine = sha256d::Hash::engine();
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha256d_64k(bh: &mut Bencher) {
-        let mut engine = sha256d::Hash::engine();
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 5b6d91db65..b7c73aa940 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -65,24 +65,9 @@ where
     /// Constructs a new hash from the underlying byte array.
     pub const fn from_byte_array(bytes: [u8; 32]) -> Self { Self(PhantomData, bytes) }
 
-    /// Copies a byte slice into a hash object.
-    #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
-    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
-    pub fn from_slice(sl: &[u8]) -> Result<Hash<T>, crate::FromSliceError> {
-        use crate::error::FromSliceErrorInner;
-
-        if sl.len() != 32 {
-            Err(crate::error::FromSliceError(FromSliceErrorInner { expected: 32, got: sl.len() }))
-        } else {
-            let mut ret = [0; 32];
-            ret.copy_from_slice(sl);
-            Ok(Self::from_byte_array(ret))
-        }
-    }
-
     /// Produces a hash from the current state of a given engine.
     pub fn from_engine(e: HashEngine<T>) -> Self {
-        Hash::from_byte_array(sha256::Hash::from_engine(e.0).to_byte_array())
+        Self::from_byte_array(sha256::Hash::from_engine(e.0).to_byte_array())
     }
 
     /// Constructs a new engine.
@@ -123,16 +108,16 @@ impl<T: Tag> Clone for Hash<T> {
     fn clone(&self) -> Self { *self }
 }
 impl<T: Tag> PartialEq for Hash<T> {
-    fn eq(&self, other: &Hash<T>) -> bool { self.as_byte_array() == other.as_byte_array() }
+    fn eq(&self, other: &Self) -> bool { self.as_byte_array() == other.as_byte_array() }
 }
 impl<T: Tag> Eq for Hash<T> {}
 impl<T: Tag> PartialOrd for Hash<T> {
-    fn partial_cmp(&self, other: &Hash<T>) -> Option<cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         Some(cmp::Ord::cmp(self, other))
     }
 }
 impl<T: Tag> Ord for Hash<T> {
-    fn cmp(&self, other: &Hash<T>) -> cmp::Ordering {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
         cmp::Ord::cmp(&self.as_byte_array(), &other.as_byte_array())
     }
 }
@@ -149,7 +134,7 @@ pub struct HashEngine<T>(sha256::HashEngine, PhantomData<T>);
 impl<T: Tag> Default for HashEngine<T> {
     fn default() -> Self {
         let tagged = sha256::HashEngine::from_midstate(T::MIDSTATE);
-        HashEngine(tagged, PhantomData)
+        Self(tagged, PhantomData)
     }
 }
 
@@ -207,7 +192,9 @@ macro_rules! sha256t_tag_constructor {
 
 #[cfg(test)]
 mod tests {
-    use crate::{sha256, sha256t};
+    #[cfg(feature = "alloc")]
+    use crate::sha256;
+    use crate::sha256t;
 
     const TEST_MIDSTATE: [u8; 32] = [
         156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243, 147,
@@ -226,8 +213,10 @@ mod tests {
         "ed1382037800c9dd938dd8854f1a8863bcdeb6705069b4b56a66ec22519d5829";
 
     #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+    #[cfg(feature = "alloc")]
     pub struct TestHashTag;
 
+    #[cfg(feature = "alloc")]
     impl sha256t::Tag for TestHashTag {
         const MIDSTATE: sha256::Midstate = sha256::Midstate::new(TEST_MIDSTATE, 64);
     }
diff --git a/hashes/src/sha384/mod.rs b/hashes/src/sha384/mod.rs
index 06d55e62eb..baa5651c7b 100644
--- a/hashes/src/sha384/mod.rs
+++ b/hashes/src/sha384/mod.rs
@@ -15,7 +15,7 @@ impl Hash {
     pub fn from_engine(e: HashEngine) -> Self {
         let mut ret = [0; 48];
         ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..48]);
-        Hash(ret)
+        Self(ret)
     }
 }
 
@@ -142,40 +142,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{sha384, Hash, HashEngine};
-
-    #[bench]
-    pub fn sha384_10(bh: &mut Bencher) {
-        let mut engine = sha384::Hash::engine();
-        let bytes = [1u8; 10];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha384_1k(bh: &mut Bencher) {
-        let mut engine = sha384::Hash::engine();
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha384_64k(bh: &mut Bencher) {
-        let mut engine = sha384::Hash::engine();
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/src/sha3_256/benches.rs b/hashes/src/sha3_256/benches.rs
new file mode 100644
index 0000000000..afefdcb727
--- /dev/null
+++ b/hashes/src/sha3_256/benches.rs
@@ -0,0 +1,33 @@
+use test::Bencher;
+
+use crate::{Hash, HashEngine};
+
+#[bench]
+pub fn sha3_256_10(bh: &mut Bencher) {
+    let mut engine = crate::sha3_256::Hash::engine();
+    let bytes = [1u8; 10];
+    bh.iter(|| {
+        engine.input(&bytes);
+    });
+    bh.bytes = bytes.len() as u64;
+}
+
+#[bench]
+pub fn sha3_256_1k(bh: &mut Bencher) {
+    let mut engine = crate::sha3_256::Hash::engine();
+    let bytes = [1u8; 1024];
+    bh.iter(|| {
+        engine.input(&bytes);
+    });
+    bh.bytes = bytes.len() as u64;
+}
+
+#[bench]
+pub fn sha3_256_64k(bh: &mut Bencher) {
+    let mut engine = crate::sha3_256::Hash::engine();
+    let bytes = [1u8; 65536];
+    bh.iter(|| {
+        engine.input(&bytes);
+    });
+    bh.bytes = bytes.len() as u64;
+}
diff --git a/hashes/src/sha3_256/mod.rs b/hashes/src/sha3_256/mod.rs
new file mode 100644
index 0000000000..9838da1ff8
--- /dev/null
+++ b/hashes/src/sha3_256/mod.rs
@@ -0,0 +1,829 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA3-256 from the family of hashes based on the Keccak permutation function.
+
+// The Keccak permutation function is defined by five functions and a state array of N-bits,
+// commonly 1600 bits. These 1600 bits are often divided into a 5x5 matrix of `u64` little endian
+// numbers, commonly called a "lane." A single Keccak round comprises of a theta, rho, pi, chi, and iota step. Each of these
+// steps are easily performed on a lane. Keccakf1600 is a function that performs a number of Keccak rounds, each defined with
+// a different round-constant.
+//
+// SHA3-256 is a hash function that accepts arbitrary data and alters a Keccak state via the
+// Keccakf1600 function. Data is chunked into fixed-sizes slices, called padded messages, each with
+// a size of "bitrate" or "rate" for short. Each padded message block is XOR'd into parts of the
+// state array, followed by a call of Keccakf1600. To pad the final message block, a
+// domain-specific identifier is appended to the message (`0x06`), followed by an XOR of the last
+// byte with `0x80`.
+//
+// To read this file, follow the example code: https://keccak.team/keccak_specs_summary.html
+// For a detailed specification: https://keccak.team/files/Keccak-reference-3.0.pdf
+
+use core::fmt;
+
+crate::internal_macros::general_hash_type! {
+    256,
+    false,
+    "Output of the SHA3-256 hash function."
+}
+// The number of rows or columns.
+const B: usize = 5;
+// 1600 bits are divided into 25, 64-bit "lanes."
+const NUM_LANES: usize = B * B;
+// Let the word size be 64. Let 2^l = 64, then l is 6. In Keccak, the number of rounds is 12 + 2l.
+const NUM_ROUNDS: usize = 24;
+// The number of bytes "absorbed" into the state-array per message block.
+const RATE: usize = 136;
+// The number of lanes a message block may be divided into.
+const RATE_LANES: usize = RATE / 8;
+
+// These create non-linear relations between rounds to avoid timing analysis.
+const ROUND_CONSTANTS: [u64; NUM_ROUNDS] = [
+    0x0000000000000001,
+    0x0000000000008082,
+    0x800000000000808A,
+    0x8000000080008000,
+    0x000000000000808B,
+    0x0000000080000001,
+    0x8000000080008081,
+    0x8000000000008009,
+    0x000000000000008A,
+    0x0000000000000088,
+    0x0000000080008009,
+    0x000000008000000A,
+    0x000000008000808B,
+    0x800000000000008B,
+    0x8000000000008089,
+    0x8000000000008003,
+    0x8000000000008002,
+    0x8000000000000080,
+    0x000000000000800A,
+    0x800000008000000A,
+    0x8000000080008081,
+    0x8000000000008080,
+    0x0000000080000001,
+    0x8000000080008008,
+];
+
+const ROTATION_OFFSETS: [[u32; 5]; 5] = [
+    [0, 36, 3, 41, 18],
+    [1, 44, 10, 45, 2],
+    [62, 6, 43, 15, 61],
+    [28, 55, 25, 21, 56],
+    [27, 20, 39, 8, 14],
+];
+
+// A `x` and `y` index into a flattened matrix.
+#[inline(always)]
+const fn ind(x: usize, y: usize) -> usize { x + B * y }
+
+// A flattened 5x5 matrix of little-endian `u64`.
+#[derive(Clone, Default)]
+struct KeccakState([u64; NUM_LANES]);
+
+// A row-column labeled output of the current state.
+impl fmt::Debug for KeccakState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for y in 0..B {
+            for x in 0..B {
+                writeln!(f, "[{},{}]: {:016x}", x, y, self.lane(x, y).to_le())?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl KeccakState {
+    const fn new() -> Self { Self([0u64; NUM_LANES]) }
+
+    #[inline(always)]
+    fn assign(&mut self, x: usize, y: usize, val: u64) { self.0[ind(x, y)] = val; }
+
+    #[inline(always)]
+    const fn lane(&self, x: usize, y: usize) -> u64 { self.0[ind(x, y)] }
+
+    #[inline(always)]
+    const fn column_xor(&self, x: usize) -> u64 {
+        self.0[ind(x, 0)]
+            ^ self.0[ind(x, 1)]
+            ^ self.0[ind(x, 2)]
+            ^ self.0[ind(x, 3)]
+            ^ self.0[ind(x, 4)]
+    }
+
+    #[inline(always)]
+    fn xor_assign(&mut self, x: usize, y: usize, val: u64) { self.0[ind(x, y)] ^= val }
+
+    #[inline(always)]
+    const fn chi(&self, x: usize, y: usize) -> u64 {
+        self.lane(x, y) ^ (!self.lane((x + 1) % B, y) & self.lane((x + 2) % B, y))
+    }
+}
+
+fn keccak_round(state: &mut KeccakState, round_constant: u64) {
+    // Theta
+    let mut c: [u64; B] = [0; B];
+    (0..B).for_each(|x| {
+        c[x] = state.column_xor(x);
+    });
+    let mut d: [u64; B] = [0; B];
+    (0..B).for_each(|x| {
+        // Avoid an underflow here with a mod trick
+        d[x] = c[(x + B - 1) % B] ^ (c[(x + 1) % B].rotate_left(1));
+    });
+    (0..B).for_each(|x| {
+        (0..B).for_each(|y| {
+            state.xor_assign(x, y, d[x]);
+        });
+    });
+
+    // Rho and Pi combined
+    let mut b = KeccakState::default();
+    (0..B).for_each(|x| {
+        (0..B).for_each(|y| {
+            let offset = ROTATION_OFFSETS[x][y];
+            let val = state.lane(x, y).rotate_left(offset);
+            let b_y = ((2 * x) + (3 * y)) % B;
+            b.assign(y, b_y, val);
+        });
+    });
+
+    // Chi
+    (0..B).for_each(|x| {
+        (0..B).for_each(|y| {
+            state.assign(x, y, b.chi(x, y));
+        });
+    });
+
+    // Iota
+    state.xor_assign(0, 0, round_constant);
+}
+
+fn keccakf1600(state: &mut KeccakState) {
+    for c in ROUND_CONSTANTS {
+        keccak_round(state, c);
+    }
+}
+
+/// Engine to compute the Sha3-256 hash function.
+#[derive(Debug, Clone, Default)]
+pub struct HashEngine {
+    state: KeccakState,
+    bytes_hashed: u64,
+}
+
+impl HashEngine {
+    /// Construct a new Sha3-256 hash engine.
+    pub const fn new() -> Self { Self { state: KeccakState::new(), bytes_hashed: 0 } }
+
+    fn absorb(&mut self, block: [u8; RATE]) {
+        for lane in 0..RATE_LANES {
+            let x = lane % 5;
+            let y = lane / 5;
+            let mut pad_block = [0u8; 8];
+            pad_block.copy_from_slice(&block[8 * lane..8 * lane + 8]);
+            let shuffle = u64::from_le_bytes(pad_block);
+            self.state.xor_assign(x, y, shuffle);
+        }
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
+    type Bytes = [u8; 32];
+    const BLOCK_SIZE: usize = RATE;
+
+    fn input(&mut self, mut data: &[u8]) {
+        while data.len().ge(&RATE) {
+            let mut block = [0u8; RATE];
+            block.copy_from_slice(&data[..RATE]);
+            self.bytes_hashed += RATE as u64;
+            self.absorb(block);
+            keccakf1600(&mut self.state);
+            data = &data[RATE..];
+        }
+        let mut final_block = [0u8; RATE];
+        final_block[..data.len()].copy_from_slice(data);
+        self.bytes_hashed += data.len() as u64;
+        final_block[data.len()] = 0x06;
+        final_block[RATE - 1] ^= 0x80;
+        self.absorb(final_block);
+        keccakf1600(&mut self.state);
+    }
+
+    fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
+
+    fn finalize(self) -> Self::Hash {
+        let mut out = [0u8; 32];
+        out[..8].copy_from_slice(&self.state.lane(0, 0).to_le_bytes());
+        out[8..16].copy_from_slice(&self.state.lane(1, 0).to_le_bytes());
+        out[16..24].copy_from_slice(&self.state.lane(2, 0).to_le_bytes());
+        out[24..].copy_from_slice(&self.state.lane(3, 0).to_le_bytes());
+        Hash(out)
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
+mod tests {
+    use alloc::string::ToString;
+    use alloc::vec::Vec;
+
+    use hex::prelude::*;
+
+    use crate::HashEngine;
+
+    struct TestCase {
+        input: &'static str,
+        output: &'static str,
+    }
+
+    #[test]
+    fn test() {
+        // LONG and SHORT are separate to match the NIST test vectors.
+        let tcs = [SHORT.as_ref(), LONG.as_ref()];
+        for tc in tcs {
+            for test in tc {
+                let mut sha3 = super::HashEngine::new();
+                let input_bytes = Vec::from_hex(test.input).unwrap();
+                sha3.input(&input_bytes);
+                let hash = sha3.finalize();
+                assert_eq!(hash.to_string(), test.output);
+            }
+        }
+    }
+
+    const SHORT: [TestCase; 137] = [
+        TestCase {
+            input: "",
+            output: "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
+        },
+        TestCase {
+            input: "e9",
+            output: "f0d04dd1e6cfc29a4460d521796852f25d9ef8d28b44ee91ff5b759d72c1e6d6"
+        },
+        TestCase {
+            input: "d477",
+            output: "94279e8f5ccdf6e17f292b59698ab4e614dfe696a46c46da78305fc6a3146ab7"
+        },
+        TestCase {
+            input: "b053fa",
+            output: "9d0ff086cd0ec06a682c51c094dc73abdc492004292344bd41b82a60498ccfdb"
+        },
+        TestCase {
+            input: "e7372105",
+            output: "3a42b68ab079f28c4ca3c752296f279006c4fe78b1eb79d989777f051e4046ae"
+        },
+        TestCase {
+            input: "0296f2c40a",
+            output: "53a018937221081d09ed0497377e32a1fa724025dfdc1871fa503d545df4b40d"
+        },
+        TestCase {
+            input: "e6fd42037f80",
+            output: "2294f8d3834f24aa9037c431f8c233a66a57b23fa3de10530bbb6911f6e1850f"
+        },
+        TestCase {
+            input: "37b442385e0538",
+            output: "cfa55031e716bbd7a83f2157513099e229a88891bb899d9ccd317191819998f8"
+        },
+        TestCase {
+            input: "8bca931c8a132d2f",
+            output: "dbb8be5dec1d715bd117b24566dc3f24f2cc0c799795d0638d9537481ef1e03e"
+        },
+        TestCase {
+            input: "fb8dfa3a132f9813ac",
+            output: "fd09b3501888445ffc8c3bb95d106440ceee469415fce1474743273094306e2e"
+        },
+        TestCase {
+            input: "71fbacdbf8541779c24a",
+            output: "cc4e5a216b01f987f24ab9cad5eb196e89d32ed4aac85acb727e18e40ceef00e"
+        },
+        TestCase {
+            input: "7e8f1fd1882e4a7c49e674",
+            output: "79bef78c78aa71e11a3375394c2562037cd0f82a033b48a6cc932cc43358fd9e"
+        },
+        TestCase {
+            input: "5c56a6b18c39e66e1b7a993a",
+            output: "b697556cb30d6df448ee38b973cb6942559de4c2567b1556240188c55ec0841c"
+        },
+        TestCase {
+            input: "9c76ca5b6f8d1212d8e6896ad8",
+            output: "69dfc3a25865f3535f18b4a7bd9c0c69d78455f1fc1f4bf4e29fc82bf32818ec"
+        },
+        TestCase {
+            input: "687ff7485b7eb51fe208f6ff9a1b",
+            output: "fe7e68ae3e1a91944e4d1d2146d9360e5333c099a256f3711edc372bc6eeb226"
+        },
+        TestCase {
+            input: "4149f41be1d265e668c536b85dde41",
+            output: "229a7702448c640f55dafed08a52aa0b1139657ba9fc4c5eb8587e174ecd9b92"
+        },
+        TestCase {
+            input: "d83c721ee51b060c5a41438a8221e040",
+            output: "b87d9e4722edd3918729ded9a6d03af8256998ee088a1ae662ef4bcaff142a96"
+        },
+        TestCase {
+            input: "266e8cbd3e73d80df2a49cfdaf0dc39cd1",
+            output: "6c2de3c95900a1bcec6bd4ca780056af4acf3aa36ee640474b6e870187f59361"
+        },
+        TestCase {
+            input: "a1d7ce5104eb25d6131bb8f66e1fb13f3523",
+            output: "ee9062f39720b821b88be5e64621d7e0ca026a9fe7248d78150b14bdbaa40bed"
+        },
+        TestCase {
+            input: "d751ccd2cd65f27db539176920a70057a08a6b",
+            output: "7aaca80dbeb8dc3677d18b84795985463650d72f2543e0ec709c9e70b8cd7b79"
+        },
+        TestCase {
+            input: "b32dec58865ab74614ea982efb93c08d9acb1bb0",
+            output: "6a12e535dbfddab6d374058d92338e760b1a211451a6c09be9b61ee22f3bb467"
+        },
+        TestCase {
+            input: "4e0cc4f5c6dcf0e2efca1f9f129372e2dcbca57ea6",
+            output: "d2b7717864e9438dd02a4f8bb0203b77e2d3cd8f8ffcf9dc684e63de5ef39f0d"
+        },
+        TestCase {
+            input: "d16d978dfbaecf2c8a04090f6eebdb421a5a711137a6",
+            output: "7f497913318defdc60c924b3704b65ada7ca3ba203f23fb918c6fb03d4b0c0da"
+        },
+        TestCase {
+            input: "47249c7cb85d8f0242ab240efd164b9c8b0bd3104bba3b",
+            output: "435e276f06ae73aa5d5d6018f58e0f009be351eada47b677c2f7c06455f384e7"
+        },
+        TestCase {
+            input: "cf549a383c0ac31eae870c40867eeb94fa1b6f3cac4473f2",
+            output: "cdfd1afa793e48fd0ee5b34dfc53fbcee43e9d2ac21515e4746475453ab3831f"
+        },
+        TestCase {
+            input: "9b3fdf8d448680840d6284f2997d3af55ffd85f6f4b33d7f8d",
+            output: "25005d10e84ff97c74a589013be42fb37f68db64bdfc7626efc0dd628077493a"
+        },
+        TestCase {
+            input: "6b22fe94be2d0b2528d9847e127eb6c7d6967e7ec8b9660e77cc",
+            output: "157a52b0477639b3bc179667b35c1cdfbb3eef845e4486f0f84a526e940b518c"
+        },
+        TestCase {
+            input: "d8decafdad377904a2789551135e782e302aed8450a42cfb89600c",
+            output: "3ddecf5bba51643cd77ebde2141c8545f862067b209990d4cb65bfa65f4fa0c0"
+        },
+        TestCase {
+            input: "938fe6afdbf14d1229e03576e532f078898769e20620ae2164f5abfa",
+            output: "9511abd13c756772b852114578ef9b96f9dc7d0f2b8dcde6ea7d1bd14c518890"
+        },
+        TestCase {
+            input: "66eb5e7396f5b451a02f39699da4dbc50538fb10678ec39a5e28baa3c0",
+            output: "540acf81810a199996a612e885781308802fe460e9c638cc022e17076be8597a"
+        },
+        TestCase {
+            input: "de98968c8bd9408bd562ac6efbca2b10f5769aacaa01365763e1b2ce8048",
+            output: "6b2f2547781449d4fa158180a178ef68d7056121bf8a2f2f49891afc24978521"
+        },
+        TestCase {
+            input: "94464e8fafd82f630e6aab9aa339d981db0a372dc5c1efb177305995ae2dc0",
+            output: "ea7952ad759653cd47a18004ac2dbb9cf4a1e7bba8a530cf070570c711a634ea"
+        },
+        TestCase {
+            input: "c178ce0f720a6d73c6cf1caa905ee724d5ba941c2e2628136e3aad7d853733ba",
+            output: "64537b87892835ff0963ef9ad5145ab4cfce5d303a0cb0415b3b03f9d16e7d6b"
+        },
+        TestCase {
+            input: "6ef70a3a21f9f7dc41c553c9b7ef70db82ca6994ac89b3627da4f521f07e1ae263",
+            output: "0afe03b175a1c9489663d8a6f66d1b24aba5139b996400b8bd3d0e1a79580e4d"
+        },
+        TestCase {
+            input: "0c4a931ff7eace5ea7cd8d2a6761940838f30e43c5d1253299abd1bd903fed1e8b36",
+            output: "dc5bebe05c499496a7ebfe04309cae515e3ea57c5d2a5fe2e6801243dd52c93b"
+        },
+        TestCase {
+            input: "210f7b00bf8b4337b42450c721c3f781256359d208733846b97c0a4b7b044c38dbb219",
+            output: "3305c9d28e05288a2d13994d64c88d3506399cd62b2b544213cf3539a8e92e2e"
+        },
+        TestCase {
+            input: "3cb8992759e2dc60ebb022bd8ee27f0f98039e6a9fe360373b48c7850ce113a0ff7b2ae5",
+            output: "3c00bf3e12ade9d2de2756506f809f147c8d6adc22e7bb666e0b1d26469e65a5"
+        },
+        TestCase {
+            input: "22634f6ba7b4fccaa3ba4040b664dbe5a72bf394fb534e49c76ec4cdc223f4969e2d37e899",
+            output: "a87e5c78837d7be0060d8f5eda975489ec961b28d7088f42a70f92414ae17793"
+        },
+        TestCase {
+            input: "6e1dcd796b2015ee6760f98fdb40e668b2cf38b05c91f6a91e83bcc8ac59f816f90a59d64e8e",
+            output: "746bf845c08aa186b5fe1ca35528232c4a491a3a2a32cd23e990bc603f3268ae"
+        },
+        TestCase {
+            input: "ee0be20320f9d44073281265a6e9fa6b9d252495624b8d016b8ef57e1b4e859d8ad3b50b89416d",
+            output: "a3257baf14ca16e1137dc5158703f3b02ebc74fc7677165fe86d4be1f38e2f7c"
+        },
+        TestCase {
+            input: "8ae2da242635b6568289bf6bec8a438dbac1f5b4d50a90bb7449bdb92a59378e23452dbcabbbe879",
+            output: "e25c44802c5cf2e9f633e683d37aa8c8db8a0e21c367808121d14d96c8a400b5"
+        },
+        TestCase {
+            input: "bdd0252dec5b798ef20e51791a18e8ca234d9bfde632a9e5395337a112dd97cdf068c9f57615424f59",
+            output: "e02c1b197979c44a5a50d05ea4882c16d8205c2e3344265f8fe0e80aed06c065"
+        },
+        TestCase {
+            input: "c4c7b6315cb60b0e6cd01ef0b65f6486fdae4b94c6be21465c3a31c416ad2f06dcf3d6eae8eecf84ca7a",
+            output: "2da21867cd6b5402d3caff92a05fddfca90199fd51a94a066af164ce3d36c949"
+        },
+        TestCase {
+            input: "b17977aced3a1184b14b0e41a04dd8b513c925ca19211e1abdc6c1b987ac845545fb3b820a083b4f7883c0",
+            output: "f91b016d013ede8d6a2e1efd4c0dd99417da8b0222d787867ca02b0ea2e80e45"
+        },
+        TestCase {
+            input: "f65c3aa1d9981a84e49fc86d938f3f756f60e3858d5e1f6957dd4d268e28d68e90ba9a11d7b192d6c37fb30b",
+            output: "3acbebf8eda9d3c99a6b6b666366c391e8200d55fd33ad8680734def1dc7ae85"
+        },
+        TestCase {
+            input: "49abba1fa98f3c4470d5dd4ed36924af4a7ad62f4c2dd13e599238883ed7d0cb95bbaae58b460332e6b7681446",
+            output: "02bcd9ea4f1aa5276f38e30351a14a072bc5d53a52d04d559a65ca46f1bcb56e"
+        },
+        TestCase {
+            input: "275645b5a2514fe65a82efac57e406f224e0259677674f1d133f00a5ee9a6d1a8fed0eadbbff5a825041d2a9715d",
+            output: "c70a874d786cd0f3f09fa4dc1bb8f551d45f26d77ad63de1a9fdfb3b7c09c041"
+        },
+        TestCase {
+            input: "cd02b32107b9a640fc1bf439ac81a5c27d037c6076e1cfe6ad229638037ac1550e71cf9557c29c2fc6017afd5a8184",
+            output: "36c73d11d450784eb99af068cd4e1cbc5768c8a2118010aceec6d852dda80d95"
+        },
+        TestCase {
+            input: "5a72e0e1aec82a6541f04883bb463b0c39c22b59431cfb8bfd332117a1afb5832ce5c76a58fcf6c6cb4e3e6f8e1112de",
+            output: "90fc3193552ec71d3315ebbb807913afd4cd2f0833a65e40d011d64de5e66513"
+        },
+        TestCase {
+            input: "43402165911890719f9179f883bbbc2a3be77682e60dd24b356a22621c6d2e3dcdd4cb2ce613b0dfe9f58629ee853e0394",
+            output: "5c4b6ceac9441defa99b10b805a725d4018b74b3e1f24ad8934fc89b41b8fd9e"
+        },
+        TestCase {
+            input: "fc56ca9a93982a4669ccaba6e3d184a19de4ce800bb643a360c14572aedb22974f0c966b859d91ad5d713b7ad99935794d22",
+            output: "e21806ce766bbce8b8d1b99bcf162fd154f54692351aec8e6914e1a694bda9ee"
+        },
+        TestCase {
+            input: "ace6297e50d50a11388118efc88ef97209b11e9dfcb7ad482fc9bf7d8deecc237ad163d920c51f250306d6cedc411386a457c7",
+            output: "f5581403a082bbf5ad7e09bdfccc43bf9683ebc88291d71d9ce885a37e952bd6"
+        },
+        TestCase {
+            input: "3bad18046e9424de24e12944cd992cfba4556f0b2ae88b7bd342be5cff9586092bb66fac69c529040d10dd66aa35c1023d87eb68",
+            output: "faed76ff5a1cd99183b311e502c54e516d70a87050cf8961c8cd46f65c1358cd"
+        },
+        TestCase {
+            input: "e564c9a1f1aaf8545a259f52c3fd1821ed03c22fd7424a0b2ad629d5d3026ef4f27cbe06f30b991dfa54de2885f192af4dc4ddc46d",
+            output: "811529c600c9d780f796a29a6b3e89f8a12b3f29c36f72b06cca7edc36f48dc0"
+        },
+        TestCase {
+            input: "6043fa6465d69cab45520af5f0fd46c81dbf677531799802629863681cea30ffa3b00836fbf49f87051d92aaeac0ed09bcb9f0755b7b",
+            output: "b0fceecdaef6c76d5fc3835b523ce2416f4a9b9bd1f90234445df0f2b689f2f5"
+        },
+        TestCase {
+            input: "2040c538c79237e6f2b8188c6375ec2f610ac2301607b9c23660c3a1e1c3a902cb2950c59aac3af28f984f6369c4debe8623dfa74c967b",
+            output: "e33dbdc0acc23fcfad3c759c4333410bd3a40efb1366ade157d2c81d65a0a6c7"
+        },
+        TestCase {
+            input: "00ff6c96b7aa3cf27d036cf20af7031434113252574bda9cf9244d85aef2593d3a7a83bff6be904b75164a1766828042bc3f4f090d98a03d",
+            output: "d000eafca34815783bed9b050c6901c97f2e77d4771a0ed724dd8f6ff1448791"
+        },
+        TestCase {
+            input: "e8df14936cce118139e690f1662f88cfbc9c333b6dea658c02cb1d959644592842542fd9d8d61a04d4a892128f0ddff7b6502efffbabe5cb0a",
+            output: "3479a9617a3adca35854c08fe987c2fe7ff2b01b04f2d952c107b3f066420551"
+        },
+        TestCase {
+            input: "4ed981a31f70dd6b70c161be1f01fc1bba54d06d9494e7eb194e213d5e0e71e0fddd49cb1f075353da22624cbe4ba871aab32906e45b6fbb691b",
+            output: "9c824a00e068d2fda73f9c2e7798e8d9394f57f94df0edeb132e78e8a379a0cf"
+        },
+        TestCase {
+            input: "7802b70c6158bc26d5f157671c3f3d81ab399db552b9f851b72333770348eb1fdb8a085f924095eb9d5ccfd8474b7ba5a61c7d7bcde5a7b44362cf",
+            output: "fa9726ccb068c0adb5d20079c35a318b3d951eb43b196c509ab790b7e9202207"
+        },
+        TestCase {
+            input: "ff83dcd7c1a488e5a128d5b746284552f1f2c091615d9519f459bc9010ca5e0ac19796c4a3fd7a15032a55a1410737d07855b07f61fbd8f5759e9218",
+            output: "8bd8d494a41acda4b7cd2994badaecff0f46ba2743458f6c3fdc0226f9492ede"
+        },
+        TestCase {
+            input: "afd4764cc7d5de16a3cf80c51d0c0d919f18700c7dc9bc4e887d634fe0a3aa94097d590e4123b73f11ccb59e23496a3d53d2bfa908056c11c52c23abfb",
+            output: "e9e3b3da648cf230f1973f3814eb81316d2a496826ea39adf4674576f97e1167"
+        },
+        TestCase {
+            input: "6fa6de509719ffbf17759f051453c0ac3cbe13346546bbc17050541074b034af197af06e41142211ee906a476039b3e07d6cb83a76aac6fca8eac307c034",
+            output: "766630993fbb651fd8d3603e3eebc81931fb1302a46791df259a6e13ca2cba9f"
+        },
+        TestCase {
+            input: "93cbb7e47c8859bef939155bea488090283ecf5023d99767c960d86baa333af05aa696fc170fb8bbac1e6473956d96b964580ee6640f0cc57be9598e55fc86",
+            output: "d3212abca1100eb7658c0f916daf2692c57a47b772ee031c4ec6ad28a4a46de9"
+        },
+        TestCase {
+            input: "67e384d209f1bc449fa67da6ce5fbbe84f4610129f2f0b40f7c0caea7ed5cb69be22ffb7541b2077ec1045356d9db4ee7141f7d3f84d324a5d00b33689f0cb78",
+            output: "9c9160268608ef09fe0bd3927d3dffa0c73499c528943e837be467b50e5c1f1e"
+        },
+        TestCase {
+            input: "4bef1a43faacc3e38412c875360606a8115d9197d59f61a85e0b48b433db27695dc962ed75d191c4013979f401cf3a67c472c99000d3a152227db61de313ab5a1c",
+            output: "8703a1f7424c3535f1d4f88c9b03d194893499478969fbb0a5dc2808a069ab8f"
+        },
+        TestCase {
+            input: "f0be5e961bb55b3a9452a536504f612a3e66aec8160a882e5156eb7278433b7ea21de31e39383d57fcdfb2fb4a8d227a9d6085fb55cad3abb78a225535da0e34efea",
+            output: "2fa180209bf6b4ad13c357d917fabb3e52c101a0cdb3f2299fa0f7f81dfb848e"
+        },
+        TestCase {
+            input: "206f1c36ba25aea73398fffc9b65c4637cc1f05a6bbee014dccbd61e3b7aa9423887bbac62152a4bf73a4b7afabe54e08720589464da7985d8e6591ac081d115df2fe6",
+            output: "558ea7c800b687380cce7e06006e1ebe0b89973f788c4caac5780f22dbf382e8"
+        },
+        TestCase {
+            input: "8cd71434c00663f3bda0205508a4a266548dc69e00ca91fde06d165b40279af92674f75bd8133e5a9eb9a075c9068f68f4b820008a1fb42d89d1d759859e68f8efc6fb60",
+            output: "085b343b08516f320a9b90fe50440a8bc51ae0850fa38d88724a4d6bd3df1ad4"
+        },
+        TestCase {
+            input: "4cf5bbd91cac61c21102052634e99faedd6cdddcd4426b42b6a372f29a5a5f35f51ce580bb1845a3c7cfcd447d269e8caeb9b320bb731f53fe5c969a65b12f40603a685afe",
+            output: "f9dbb88c5bb4415e17dee9222174538eeab371b12d8d572cfdf55b806e3158e4"
+        },
+        TestCase {
+            input: "e00e46c96dec5cb36cf4732048376657bcd1eff08ccc05df734168ae5cc07a0ad5f25081c07d098a4b285ec623407b85e53a0d8cd6999d16d3131c188befbfc9ebb10d62daf9",
+            output: "3571326a1577c400b967ac1c26df2a0dcf5db7070eac262a8071da16afa7c419"
+        },
+        TestCase {
+            input: "981f41a83d8f17f71fc03f915a30cd8ac91d99aa1b49ef5c29fb88c68646b93a588debcd67474b457400c339cca028731df0b599875ab80df6f18b11b0b1c62f2a07b3d8209402",
+            output: "62aea8760759a996f4d855e99bcd79e9a57ea362522d9b42fd82c12c9294a217"
+        },
+        TestCase {
+            input: "5c589fc54fefc4d6e2249a36583e1992fc6b8a9c070e8e00c45a639af22063e66ae5cdb80238c82db043a5e1f39f65626e6d7be5d6a2d3380fa212f89211200412e5e4315fc04e40",
+            output: "18deba74e9d93ae7df93c6c316ef201bf5e3a661e68868e14d4f56264f5d858c"
+        },
+        TestCase {
+            input: "7c8691e7b2560fe87fcc5e2877f7e3c84d9101eca4818f6322a58986c6cf05627c0d6919ef2edc859f81fa1f33e0cc1f10edf7e52a9c33981af2ff0d720c94ea4d62170b2a4d1224fa",
+            output: "5a5a438b57c1b3ce8756094252362afeaa9fc91cd45b385d16994ec8af49aa6b"
+        },
+        TestCase {
+            input: "97359b564b2bc20800ed1e5151b4d2581a0427ce9539d324c3637cfb0e5378dc2cf6d72946e2a3535a2f664ede88ed42a6814c84072b22c43de71e880a77c2d9a05b673bc15a82e3255f",
+            output: "be54f2e435f760d5b77c0ae61ef0aa7f5f3366f47819f350dc8a39aff8c73a8f"
+        },
+        TestCase {
+            input: "a0dfaecd3e307c5ddf9a93603f7e19725a779218734904525b14586ff0ce0425e4efe7e1c06e745c28ed136f6031c4280fd4061d433ef700b6d1bc745064231fecf387015f94f504b6ad8c",
+            output: "60d80f1c703dad5da93db222fb45fb7fa768c8aa2787f4b81f1e00365b8f49e2"
+        },
+        TestCase {
+            input: "568d66d061306c3419a1928ce7edc8e3400c30998f09bdac6f63ff351eb23d362e8dc5927eac805d694ac9563dcd7fb2efa9591c0d827af9f39146f0424873aa8e3963d65734b1713baf0a44",
+            output: "7a4fe37f296991121792dd7c2c30390725a1eebbf20b766a5a1c3c6c3646d996"
+        },
+        TestCase {
+            input: "d65b9f881d1fc7f17d6dd429faca8404e6ce60fba7d89b7fba003c8ef84d8083182979327611fc341291ba80dc70ad3b2f28b6d29b988445e7fdb7c6561f45822ac81dbf677a0b27d961dc6358",
+            output: "51cc71b6934afcf28fa49942b76323f36cd6a0aecc5a0e49c10994ddcabdbb80"
+        },
+        TestCase {
+            input: "711c88adf13e7a0e694652f2b9a397543f4937fafb4ccca7f1ad1d93cf74e818d0fedfaee099f019014ec9e1edfe9c03fdb11fe6492ad89011bf971a5c674461de15daff1f44b47adad308baa314",
+            output: "1780e52e306858478290c46b04d8068f078a7f6ad8e3790a68fc40dccfbdadc9"
+        },
+        TestCase {
+            input: "f714a27cd2d1bc754f5e4972ab940d366a754e029b6536655d977956a2c53880332424ddf597e6866a22bfca7aa26b7d74bc4c925014c4ed37bfe37245fa42628d1c2ee75dc909edc469ee3452d894",
+            output: "f4afa72f3e489ad473dc247aae353da99fb005b490e2c4e1f5bd16a99732b100"
+        },
+        TestCase {
+            input: "fe0c3280422c4ef6c82116e947da89f344d6ff997bf1aec6807e7379a695d0ba20ae31d2666f73bbdbc3a6d6ac2c12dcfb5a79173dfc9cd2e0d6000e3114f2767edec995772c6b47dadc136d500251e5",
+            output: "89198e2363efd4e0ba7a8a45f690f02712e6f856668517bae118d11e9a9dc7cc"
+        },
+        TestCase {
+            input: "02e238461d0a99d49c4cd16f442edf682c39b93114fc3d79f8546a99e5ead02f0cfc45081561da44b5c70eb48340418707fd6b2614580d5c581868ba32f1ee3ac34bf6224845b32ba7f867e34700d45025",
+            output: "abef81b33591eedcac0cf32fb5a91c931f2d719c37801409133552170ce50dbf"
+        },
+        TestCase {
+            input: "fb7c8cd4031007f8159d5c4c6120dee6777a3ace0a245b56f31e8aae7828dab3cf35c308de1d0d684592ef3a9e55796603a92f68d109f7a3ac1635f7c4d334955614c812753431bb0a0743291a0fc41547f3",
+            output: "5a67284d39e4f37caa64ca1a54593c35f6d8f3a3ec20d460393a39f6f57c4486"
+        },
+        TestCase {
+            input: "6b2e868c7d0ee1c240d3a67e2fdf36e8e23817c02644a54453d10454da5859d41e833a5285ec63e8ce28aa64a50435a7740eea4b7d5827892678b35993d3f5da7a1c64f533173f3d0fa37e1aebf70827052c26",
+            output: "aecf5dab6fea9ffd1bce2cdfeec0bee9d214a669e8306d5b6688afa8957fc91f"
+        },
+        TestCase {
+            input: "e5f3ba000c43bb6aca4e0a711a75912a48241cffa5b4b0b17f901f9e5097d94036c205f7a307d008567d05e58ac0dfaf6d971bf9d3d450cf2c7c83f6b328f676e9ab425642f5a5a71e389dc4fa49b6d7e848a09f",
+            output: "182d6e4316f4bc18d7163b1b21462d99f99c6f34d2c00ee771ce54fd6c5018b9"
+        },
+        TestCase {
+            input: "939c61e68af5e2fdb75a2eebb159a85b0c87a126ce22701622f5c5ef517c3ab0ed492b1650a6c862457c685c04732198645b95f84ccb0e726a07ce132827a044dc76b34d3f19a81721f1ea365bc23e2604949bd5e8",
+            output: "121057b0b9a627be07dc54e7d1b719f0a3df9d20d29a03a38b5df0a51503df93"
+        },
+        TestCase {
+            input: "9eadaf4811a604c65eaa7b1c6e89f2c0ab96bebec25a950ba78aac16d9371ca1e7458acf331e077ef6a735d68474ab22d2389bdf357fb2136c9f40e1e1eb99592c2bbb95d94931016b4d37faa08b1e9bf71bf2d3708a",
+            output: "c237194b902e48dca5bd096cb51562079d0cdccb2af8088197676c17b0896be2"
+        },
+        TestCase {
+            input: "71dcca239dced2ac5cc49a9bf9ea69a99be22ba62216716b524db80f337dee5eb7e032869e4adc1497babd1fa82fa8c3cfbd30d2eadfb4c5d40f99f9d194d7182c9cb7d41e8adbdcf2917e086782fdd756e2961c944070",
+            output: "377d1cffb626735810b613fd31ef9bbb4577cd752521abe3a41afa921e623da0"
+        },
+        TestCase {
+            input: "ea130d3236bca7dffb4b9e50e805309a503e7347227aeb9f1bd15c263a98dd65753d2eedaa734b9ad88f41158f32419ca529f3062b910c019f3f239f635fc1116e5ab7b242feb4471ed9168474e501d39d6bae52cc21061a",
+            output: "85c7a52d53f7b41162ea9f1ef0d07c3fb8f0ec621617f88cb3828ebe5388ab3d"
+        },
+        TestCase {
+            input: "28f1be1156792af95c6f72e971bf1b64e0127b7653ff1e8c527f698907a27d1544815e38c7745529bc859260832416f2b41cd01e60c506239a7bf7553650bf70d1fe7a2c1220ac122ea1e18db27490447d8545a70bf0ffc8fa",
+            output: "b2eb3762a743d252567796692863b55636cb088e75527efd7306a2f6e3a48a85"
+        },
+        TestCase {
+            input: "c8400ef09c13e8acc8a72258f5d1d20302c6e43b53250c2f6c38ff15be77e3cac04d04b8421fc8fdff8be5ca71edd108e9287b42dea338bf859100eea376da08a0e695f0dc90b95e467cbd3c2a917a504a5ae01c310ae802c4bd",
+            output: "69966e89b7bc7f39cd85791b92180ff3fed658d8240e393e1e6d7c24b8d0ac95"
+        },
+        TestCase {
+            input: "a48950c961438e09f4d054ac66a498e5f1a4f6eabfde9b4bf5776182f0e43bcbce5dd436318f73fa3f92220cee1a0ff07ef132d047a530cbb47e808f90b2cc2a80dc9a1dd1ab2bb274d7a390475a6b8d97dcd4c3e26ffde6e17cf6",
+            output: "44c00cf622beca0fad08539ea466dcbe4476aef6b277c450ce8282fbc9a49111"
+        },
+        TestCase {
+            input: "e543edcff8c094c0b329c8190b31c03fa86f06ace957918728692d783fa824ba4a4e1772afbe2d3f5cba701250d673405d2c38d52c52522c818947bcc0373835b198c4cc80b029d20884ac8c50893c3f565d528a0cb51bf8a197d9d6",
+            output: "6d5260384f3cefd3758fb900dcba3730d2b23cee03d197abeff01369dc73c180"
+        },
+        TestCase {
+            input: "4e10ab631718aa5f6e69ee2c7e17908ec82cb81667e508f6981f3814790cfd5d112a305c91762c0bd9dd78e93ef3a64c8be77af945b74ff234a0b78f1ed962d0d68041f276d5ea40e8a63f2cab0a4a9ed3526c8c523db7cb776b9825b4",
+            output: "d88e5f3b2d0a698fd943233760a3000a3360d9040e7374b22e39ea58d868102d"
+        },
+        TestCase {
+            input: "604d8842855354811cd736d95c7f46d043a194048b64bf6cda22c3e0391113dcc723e881ae2ad8dc5740aa6bda6669ddb96bb71acd10648380693f7b3d862c262553777004bd6852831618519fbb824759f4dd65af1b2a79cc01096d7c8d",
+            output: "8a8ab6cf5c02b9ae8f4c170740eff1592f3eda11d3420ac8b421d93cfbb35db8"
+        },
+        TestCase {
+            input: "628180e14f41ebdfde3b4439de55ee9cd743d41040f3457ef2280370dd659619fa0ce69580c709725b275a6eda8bcb82a8447c20fdf68cba15412f83e2a10079fe9399a3e3fa61975ec0a64041c0ecde59e4844e9f8a608cb22d2576854182",
+            output: "8d154bf6f9cb72efc0d8b3927a8f690060d1d48bbe5cc72094d2c8b149a75132"
+        },
+        TestCase {
+            input: "fc150b1619d5c344d615e86fca1a723f4eeb24fbe21b12facde3615a04744ef54d8a7191a4454357de35df878cb305692278648759681919d1af73c1fb0ff9783678aec838da933db0376e1629fcca3f32913f84bc2ff3ffc3f261d2312f591c",
+            output: "3f626c8bb20a132495bd3022b3fcd0ce0604b91a9d70132dab4099f73dde23d5"
+        },
+        TestCase {
+            input: "6dadbecdd15e5646e3f37a6fe5b328e06113cce3c8cf07285939afba44d117321017902b3a9d2ff51f60d18e1b585dcdf34e49e170ee60fa4d1dc246548d2c1fc38e7983f42769c43d65a28016f3f4d479ebe1cd8fec5d1f886dd21aca5067d94f",
+            output: "9098ea34c40b541b153e80a8bd92da19432b18b7d329760b302f8a54c395dd06"
+        },
+        TestCase {
+            input: "9cc5fd3035b72dc63b8c3c326fd013081e6b8716f526d3fe176b45256d4c37cc3dc8417dff49ada96c702b8fd715c65fc08a17a0a720b9cf1eedfd4922ccde6baba437f782ee33b95371056b0350dad743470c3b663299f16fcfd34f6fc459cd0ee4",
+            output: "b0c04f24bb6d3d4fcbfdf9222d0e886f1eb60a0566a478085f7623a025a5b981"
+        },
+        TestCase {
+            input: "f3f063fbcf2d74aa5a02d240c962ed7bb119b3a212bdb41594e28428108e613152ed16e01e451fcf702b0e5a08f82eb12677652b93e05fdee00ae86cf2dc9a1fbf05b93952ec5b8515eacc324fb830e1ec236afd7d073d4b7f7ab1c2e048b99cbfa012",
+            output: "f930d79360b581b1bbfdeac57133a339444f5c44538c921631eabaf058277d32"
+        },
+        TestCase {
+            input: "840739a3d6992c13ec63e6dbf46f9d6875b2bd87d8878a7b265c074e13ab17643c2de356ad4a7bfda6d3c0cc9ff381638963e46257de087bbdd5e8cc3763836b4e833a421781791dfcae9901be5805c0bbf99cca6daf574634ec2c61556f32e642730510",
+            output: "19795657e08cfbb247a17cf209a4905f46e4ddf58eea47feee0be9bb9f5c460f"
+        },
+        TestCase {
+            input: "4a51b49393ab4d1b44fb6dc6628855a34e7c94d13b8b2142e5d5a7bf810e202cefdca50e3780844a33b9942f89e5c5b7dd6afb0a44541d44fb40687859780af5025fecc85e10cf8249429a3b0c6ff2d68c350c87c2fcbf936bd9de5701b2c48ce9a330c9ee",
+            output: "128fb4114e43eefd19277c708be9e6873e66d7fd59c58a1485b7b015facfa795"
+        },
+        TestCase {
+            input: "afc309e6b7b74dfb0d368e3894266fc4a706c3325e21f5550d07a6560e3d9703c134ca6ad078e4a7b82ad6fa85b0bc1ddcab05d43f29d5c58d1da78ac80c37051b089ff31ce2c0c44e9ce3abea1da0f1df28008e178fdefafca493413bf1d256c729d0a9225e",
+            output: "03e782b01a4ba10f640470bb3cae487eb9cbbaab8c9941978b194f6a312cf79e"
+        },
+        TestCase {
+            input: "c5ae750f2230642092397b84ad5526c46ae9480ada16892816e0f2db7690b751035653ea2f33da3cc4168b591b46a5548eff7d012f60ccfdbb854deec9f0880c472de8e127b5144c56147cccee4732fbac68fc59a48da74b33ed9e643644bbe279795c7c737eba",
+            output: "f64b7ab243ce6e6c04b483888ba8a655465c21d95eb60c7b8d6e566a3811bae2"
+        },
+        TestCase {
+            input: "603e13f61499e12ec6b33b68847a281d314f54dc705c0f3fc428981ff5689c04b519fadf83cbc9fcd0409c326035045df480570e265bb080940037ce4076a36437aafdb371c1a62af9ad9b614dfef89708fbbb5ebef2cb9528cc399781e4c5b22f1aa4dba623809f",
+            output: "5f76962fd3d373e5db2953c0823a51fe81f874450bedf7e46876394b04d3ef66"
+        },
+        TestCase {
+            input: "e03115cfa19efcd796da389063c4be6acce684d983f8edfb3da6887b0b94fbb5e89e3a1a8e64fdd68f0670b1a02c2c33384a660c5a2266b3ae8a3b4cd76faecf011a7467b9b2a818020278a5a57d1eb1c87f1224c2d67dd02e81f1553eb75841532c2b7cca8fe5e418",
+            output: "d107ee6ee4a58871a33c49657faa2573e475f11918c4a4e3801d0e17fb93c6e3"
+        },
+        TestCase {
+            input: "0e6c1d58b1b9d3a2d399aafd60529e07d483a2755bb7e44c373b5355632d5fca76d6ff56c93af93ddcec5ed6f62753420c1b1758e48542df7b824b00a3a54dfaf0470b18d51e31e10b12dd8e324b5dc1bb8f3b7305cb762ec6ef137dadffd4a2466748861d9004f626b0",
+            output: "02ab2dbb02944354799051247b1a25c19f3696e1afcb502b859e83798b33fd77"
+        },
+        TestCase {
+            input: "6db2a43a229b10c3629249fc5136468b4d84df7b89ec90ebf7aa7a036c53aa2dffae9e81b2c60580543dc706a5e3457abc87e248a60ec29150c2d221a6ec08a1fda4ec0daee8576904ec7ab059b1230e7bd93c4e55ba9496cbb1e352e5b8086e303b94c861288ce53c466b",
+            output: "8cc4d39b2f5ba0bc9d2ee2a8777cf08533e60cc69b65a7b31c5c2121193aa31e"
+        },
+        TestCase {
+            input: "31d995f7ff8b6de70829a8336c610f10df2c866107a4922b25151849f8566861df5a79163d02767f21357ad82733997899261f03dafb1ce1056f20efd16d4374b89768565823c38e19e899d910b847b023f1867b6e4fed02e604b8243c0bc7cb05b9ea1f17955bfa36698c9c",
+            output: "c99c7191b34c9ad3f941d4ad442cc865205cbb4c2a6927c592e831cbc4d36fcf"
+        },
+        TestCase {
+            input: "cb0b8cb7de621c8e0a0fc6be2fc18d0e8818a2c2dd0b3219fa87831a61583f903c4d105495976ccac973b3ae3a09771145931a9e74c19f22f45cba4c492b29b1401347122581dfe2370d3e0359578cd10a355c619711810a8f8c232578671312c0a45c7cf7e81bdd3b249044f3",
+            output: "6d2f57a7e42b35369cf2cd60caf9e65aca7d9aa019e6824bb806348f1acf3c7c"
+        },
+        TestCase {
+            input: "48dff78aed5f6e823054924a78dc1b8e51a117f1610181529f6d164ebf0f6406f0b02422cad8c916823759a361437ca17423d3fd84cc8afe486a31ccda01c732685418a32c064a7b9effb288e811ecc99adb2a759feecc3f702f31d9877dcdb717937c15fa2f163bea744400f58c",
+            output: "14b631f0f00a3024ad1810dabf02711e28449668abe27f69380942268968d4f6"
+        },
+        TestCase {
+            input: "06cc9fa542ceb35c88fb6ab82c29d5dcd530f807d3f1c3bcb3974421101d1aa6ac112de6bf979cd28eb0f70c40bcaf91ed3eca9bf9e0dbc6a0b73271d1c7506740ca9ebfb72d5e00ac5ce189193ffa308804b42a6d20402bb99031cdac65ec36eb7f59f5d299df2e0b8690f760b9a0",
+            output: "574fd82a9fceb8f7bbbf244d16e0412cbda8153b720846c32b8f10fe5779a881"
+        },
+        TestCase {
+            input: "8d93627c0b7cbf61a7fe70e78c2c8ed23b1344b4cfed31bd85980dd37b4690e5b8758f7d6d2269957a39a1ac3451cc196696ae9e9606a04089e13456095a1ce1e593481b3ac84f53f1cb10f789b099f316c948398ad52fa13474bdf486de9b431bd5d57ef9d83a42139a05f112b2bd08",
+            output: "344ec86642eabb206b2fd930e4c5dde78aa878577d6c271cb0069d4999495652"
+        },
+        TestCase {
+            input: "d0af484b8be6b41c1971ae9d90650a1e894356c9191d6be303fa424f2b7c09544ec076a0f1865c8c97927ca137529d5bedc0df2ef08a4cc7c470b094b1eeaa86731c041633d24086b60f7369d59c57652dec9b3817477df9db289ba020e306c9a78a99b539128992deb23cfc508c5fc3af",
+            output: "b7ba998726477c32792e9c3eddc1cb6feb7c3933e49f2e7590d8ce7a2113e6f8"
+        },
+        TestCase {
+            input: "b212f7ef04ffcdcf72c39a6309486c0eeb390ff8f218d6bd978b976612f7f898c350e90bd130723e1126af69295019b4f52c06a629ab74e03887020b75d73f0f78e12785c42feb70a7e5f12761511c9688c44da6aaa02afa35b31edc94c3a0779b6ab9462525c0ccfba76986f873fe1e6ba9",
+            output: "2f26b96c1fa3f3dee728f17584e733b4189821c659b8885a5fb1d12d60d2aaa9"
+        },
+        TestCase {
+            input: "86591ada83fba8175a0fe91d264e7f9b2df97ee4c32570e76b579d6140508951932abdadd6a4ca53b8bb8c42927aac0a02126881d52d97b82b80e72dd59f6a42021651ee1bb5f7b3eb2b21d003d784b75dda87c13f714b216282e8175474fa661b445d071bd5341f3a88302f410d0f8a857962",
+            output: "e3edbc8c42ce5d2384dfb24fb1de5d4798b1bc3cc78c97033894040dfa6feb6c"
+        },
+        TestCase {
+            input: "92b5a8e84b6a2ac4d5b1e61d63804abd641dd630058ec6d5f752f135724ef1947a0a84c6611d32448de6307f7b7d857404e96b81df94f87768fcfdf09faa2fe37468847542afe012995ff1bd40b257a47a7309f8896bf4fb711de55bfeb3a8be0837729ef6067c578182f17ebb080a754f22773c",
+            output: "80ed0a702812297c2aa1b6b4b530c2b5ed17ecfba6d51791cf152d4303ced2e6"
+        },
+        TestCase {
+            input: "d284a0a9a4de5d4c68cc23884c95ad7619aa39b20a2cf401deaeb3362c3ce356f79cc3fa82d3d1f565ec8137e1f435f171496afaa1152f722315dca5209f0031cce39b6c3d718e007dfb4fd8de5ce1408dda04476aa8a96817afa86a4f8fb5857ae091c67ebd7db5d783f434ead699aa96e56f610d",
+            output: "654eccefd0a4fdb2ac0ab56288c64399b37bc4d57ff4a9f1cce94362fc491bda"
+        },
+        TestCase {
+            input: "f57f0f8795385b805246a0a2573afc274346a9eccf50c626b0455a50bfb09668578b5a5afe54fbbd486444bdf97dba586aa224ce2e2b4b52f418ff06afa65a26f5204983a5f84734cd166c88cb70a73fb2db48f9ef20c1ee2c53ade07460114e98e7e2ebd24ac84ea90422eb143c4a42e2991a565959",
+            output: "135ec8b144a667dceae8fadd287df81c10ef3ebef87ff2fb56e60ae708a88f3b"
+        },
+        TestCase {
+            input: "2a41a52e6578873588a57f11f1be7c7eb398d01f3bfdec2c33fe6b65a68a534a6540978daa82e0c8fccb8c6c5242f7f97b8ffa75bdedb217bd8083439eea5cbb6d193c13bd62f5658ed4304774c6b1faf5b3dce432487840cabab415fb5d67640a739ca6e5414e760869708a9d7331e7e7ad7d55e035c7",
+            output: "a6a1b8a26f6f440f19f16dce1d3001477d73ee7f6c374bce2922167b81970d6a"
+        },
+        TestCase {
+            input: "4d11aa5d3c6b6900f49ff90dd815744572be5648b64bde638b9db7a9877dd745fa8ea80e2f7f655cee85c71a4509e21d899e49b4973579815f947587a404ad83fd4a248020d9d2a65f46485373fc926d793161f63a196ae0af590923c5be2a0e5d2f69da97e0788550c9c1dee9574ddc4a61e533275d7729",
+            output: "fc5159f0ddd6d765c85fcc3fc3ac1dc0d317d8ea0b110e96ac9f7a398dc386c5"
+        },
+        TestCase {
+            input: "05cd99bfe031d123ca7061d3de0956f4bbf164bad792db881713d6599ddab55ee24fcee804e360896152c8766424f8309f7a24641a07be0feb5da5e5076a9af45842f385101f93433ca5199f9c6b5872b2b808e4198aba8e18dd12db772930b4912d6f5cabeb529884f4bb142de55e021b3276047b22b64cc5",
+            output: "8aa07742e6f1f47ad020ed6684edc8dba4af36b782955f0f972be3ae980aea0e"
+        },
+        TestCase {
+            input: "529684398d68bdc19e7a00ce32cc1a8c1315b97f07137474f61f0cb84a04f2879b1109c78c6dacf7f0abf362329e3298f36fc31ef4ec06653723a5f961301dfb63537ad15946611cb2cd54ea928e322e7423fd6d146ee0b98c2c71e3bdcd33edf0845fbebd9ae4192d07acd01b432135e05af0d22f3f0c5a3d62",
+            output: "a07049b6ebd7b355479a3d802fda436b83ae6747d741cf9626f7c62f47cbd563"
+        },
+        TestCase {
+            input: "982fb5f4af498a4a75e33a033235ea3ddb70d9d236519f883ff5b388cbef30126b98d96e93a65a26fb00d17246d18cf4e2db14a52f0f6b10e35a93beadc14ff118b02e95b38fc4736f973ba848e40b5527cb0599076d96bc578c4aada09e8faf6820bc4f562d5199974f808b7f95edca74e6b3940894a7f66534e0",
+            output: "09c60fec5a089a23f5da3ed2492aa21fcf7aa36183850fafc15ae8c63f596db0"
+        },
+        TestCase {
+            input: "ca88614828f8acdb5fcffab6bb2fb62d932b7808e4d9cc3139a835b0cef471d9f4d8ffc4b744dffebf4f997e74ce80db662538bceb5d768f0a77077e9700149ea0e6a46a088a62717216a14b60119dd19c31038ed870b4709161c6c339c5cc60945a582263f3be9a40cd1a04c921947900f6e266f2390f3c970f7b69",
+            output: "fe2d4183ccdaa816b4446a9b6c07d0ba4b42ac743599db5dc482b1941f443c71"
+        },
+        TestCase {
+            input: "ab6b92daf83275cb9c1b76cfb59fbcc8ac53188e0b6980918e7ac0c07c836ca9372d19e11251cca664bbb3c3db2e13b412a9820b65e95612042f5db24643cf9340b9808597735a1f92670ba573a2fb2f088d81087d70565574344af7576d35b2ed98318e2ca0067d4fa8e63f28045b83b6887d4ffa0668a10712ed5759",
+            output: "744538e1ae1cd7357710b56c3bc6f1bd7a8564118a1e0f9acc30fcf0b5396eef"
+        },
+        TestCase {
+            input: "bfd4c7c8e90858ccf9c8834abefd9c1846ca4a11966fdd139d6de24a6bebf4b19f58d5d51e52bddd0bc6f1c7f35998f44707cae7100aeb4adefe373101429da3fca1d15737329dbbf47c783a84de59bfbb2fcd75a1a148d26aebb8d3a9a76089c0f8e4d49b71a06f9e323e2cdb54888189887a44b1fa9cb32b7c8fb7c9e0",
+            output: "58b17843bc851a721c5a258eef57b3854d02190e732d9b8e7a9f926ac409c173"
+        },
+        TestCase {
+            input: "c5019433c285da2bb93f119e58b4f36cd1e4d99dda35dbf4f8ae39c7fe65fa0ed03bd2b96dc649472d8f1a94477ed9f29592d97c9cd54da7c790ad1af3bb5cc030b7871bc64050db779d2caf0419895bf3b7b50b8e22fbe62fe30fe7bbd6ace86ddf7b00d5d9370f20cf0f97996f4bce70bb33f1ba022cdaba0f25d55fa031",
+            output: "f7c92a3fb7f180370d628be78de874d693f74ccc7a54c741634258d8c512fd7f"
+        },
+        TestCase {
+            input: "84b60cb3720bf29748483cf7abd0d1f1d9380459dfa968460c86e5d1a54f0b19dac6a78bf9509460e29dd466bb8bdf04e5483b782eb74d6448166f897add43d295e946942ad9a814fab95b4aaede6ae4c8108c8edaeff971f58f7cf96566c9dc9b6812586b70d5bc78e2f829ec8e179a6cd81d224b161175fd3a33aacfb1483f",
+            output: "8814630a39dcb99792cc4e08cae5dd078973d15cd19f17bacf04deda9e62c45f"
+        },
+        TestCase {
+            input: "14365d3301150d7c5ba6bb8c1fc26e9dab218fc5d01c9ed528b72482aadee9c27bef667907797d55514468f68791f053daa2df598d7db7d54beea493bdcbb0c75c7b36ad84b9996dca96354190bd96d9d7fbe8ff54ffaf77c55eb92985da50825ee3b4179f5ec88b6fa60bb361d0caf9493494fe4d28ef843f0f498a2a9331b82a",
+            output: "9b690531dee948a9c559a2e0efab2ec824151a9175f2730a030b748d07cbaa7f"
+        },
+        TestCase {
+            input: "4a757db93f6d4c6529211d70d5f8491799c0f73ae7f24bbd2138db2eaf2c63a85063b9f7adaa03fc348f275323248334e3ffdf9798859f9cf6693d29566ff7d50976c505ecb58e543c459b39acdf4ce4b5e80a682eaa7c1f1ce5fe4acb864ff91eb6892b23165735ea49626898b40ceeb78161f5d0ea4a103cb404d937f9d1dc362b",
+            output: "1ac7cc7e2e8ea14fb1b90096f41265100712c5dd41519d78b2786cfb6355af72"
+        },
+        TestCase {
+            input: "da11c39c77250f6264dda4b096341ff9c4cc2c900633b20ea1664bf32193f790a923112488f882450cf334819bbaca46ffb88eff0265aa803bc79ca42739e4347c6bff0bb9aa99780261ffe42be0d3b5135d03723338fb2776841a0b4bc26360f9ef769b34c2bec5ed2feb216e2fa30fa5c37430c0360ecbfba3af6fb6b8dedacbb95c",
+            output: "c163cd43de224ac5c262ae39db746cfcad66074ebaec4a6da23d86b310520f21"
+        },
+        TestCase {
+            input: "3341ca020d4835838b0d6c8f93aaaebb7af60730d208c85283f6369f1ee27fd96d38f2674f316ef9c29c1b6b42dd59ec5236f65f5845a401adceaa4cf5bbd91cac61c21102052634e99faedd6cdddcd4426b42b6a372f29a5a5f35f51ce580bb1845a3c7cfcd447d269e8caeb9b320bb731f53fe5c969a65b12f40603a685afed86bfe53",
+            output: "6c3e93f2b49f493344cc3eb1e9454f79363032beee2f7ea65b3d994b5cae438f"
+        },
+        TestCase {
+            input: "989fc49594afc73405bacee4dbbe7135804f800368de39e2ea3bbec04e59c6c52752927ee3aa233ba0d8aab5410240f4c109d770c8c570777c928fce9a0bec9bc5156c821e204f0f14a9ab547e0319d3e758ae9e28eb2dbc3d9f7acf51bd52f41bf23aeb6d97b5780a35ba08b94965989744edd3b1d6d67ad26c68099af85f98d0f0e4fff9",
+            output: "b10adeb6a9395a48788931d45a7b4e4f69300a76d8b716c40c614c3113a0f051"
+        },
+        TestCase {
+            input: "e5022f4c7dfe2dbd207105e2f27aaedd5a765c27c0bc60de958b49609440501848ccf398cf66dfe8dd7d131e04f1432f32827a057b8904d218e68ba3b0398038d755bd13d5f168cfa8a11ab34c0540873940c2a62eace3552dcd6953c683fdb29983d4e417078f1988c560c9521e6f8c78997c32618fc510db282a985f868f2d973f82351d11",
+            output: "3293a4b9aeb8a65e1014d3847500ffc8241594e9c4564cbd7ce978bfa50767fe"
+        },
+        TestCase {
+            input: "b1f6076509938432145bb15dbe1a7b2e007934be5f753908b50fd24333455970a7429f2ffbd28bd6fe1804c4688311f318fe3fcd9f6744410243e115bcb00d7e039a4fee4c326c2d119c42abd2e8f4155a44472643704cc0bc72403b8a8ab0fd4d68e04a059d6e5ed45033b906326abb4eb4147052779bad6a03b55ca5bd8b140e131bed2dfada",
+            output: "f82d9602b231d332d902cb6436b15aef89acc591cb8626233ced20c0a6e80d7a"
+        },
+        TestCase {
+            input: "56ea14d7fcb0db748ff649aaa5d0afdc2357528a9aad6076d73b2805b53d89e73681abfad26bee6c0f3d20215295f354f538ae80990d2281be6de0f6919aa9eb048c26b524f4d91ca87b54c0c54aa9b54ad02171e8bf31e8d158a9f586e92ffce994ecce9a5185cc80364d50a6f7b94849a914242fcb73f33a86ecc83c3403630d20650ddb8cd9c4",
+            output: "4beae3515ba35ec8cbd1d94567e22b0d7809c466abfbafe9610349597ba15b45"
+        },
+    ];
+
+    const LONG: [TestCase; 5] = [
+        TestCase {
+            input: "b1caa396771a09a1db9bc20543e988e359d47c2a616417bbca1b62cb02796a888fc6eeff5c0b5c3d5062fcb4256f6ae1782f492c1cf03610b4a1fb7b814c057878e1190b9835425c7a4a0e182ad1f91535ed2a35033a5d8c670e21c575ff43c194a58a82d4a1a44881dd61f9f8161fc6b998860cbe4975780be93b6f87980bad0a99aa2cb7556b478ca35d1f3746c33e2bb7c47af426641cc7bbb3425e2144820345e1d0ea5b7da2c3236a52906acdc3b4d34e474dd714c0c40bf006a3a1d889a632983814bbc4a14fe5f159aa89249e7c738b3b73666bac2a615a83fd21ae0a1ce7352ade7b278b587158fd2fabb217aa1fe31d0bda53272045598015a8ae4d8cec226fefa58daa05500906c4d85e7567",
+            output: "cb5648a1d61c6c5bdacd96f81c9591debc3950dcf658145b8d996570ba881a05"
+        },
+        TestCase {
+            input: "712b03d9ebe78d3a032a612939c518a6166ca9a161183a7596aa35b294d19d1f962da3ff64b57494cb5656e24adcf3b50e16f4e52135d2d9de76e94aa801cf49db10e384035329c54c9455bb3a9725fd9a44f44cb9078d18d3783d46ce372c31281aecef2f8b53d5702b863d71bc5786a33dd15d9256103b5ff7572f703d5cde6695e6c84f239acd1d6512ef581330590f4ab2a114ea064a693d5f8df5d908587bc7f998cde4a8b43d8821595566597dc8b3bf9ea78b154bd8907ee6c5d4d8a851f94be510962292b7ddda04d17b79fab4c022deb400e5489639dbc448f573d5cf72073a8001b36f73ac6677351b39d9bdb900e9a1121f488a7fa0aee60682e7dc7c531c85ec0154593ded3ae70e4121cae58445d8896b549cacf22d07cdace7625d57158721b44851d796d6511c38dac28dd37cbf2d7073b407fbc813149adc485e3dacee66755443c389d2d90dc70d8ff91816c0c5d7adbad7e30772a1f3ce76c72a6a2284ec7f174aefb6e9a895c118717999421b470a9665d2728c3c60c6d3e048d58b43c0d1b5b2f00be8b64bfe453d1e8fadf5699331f9",
+            output: "095dcd0bc55206d2e1e715fb7173fc16a81979f278495dfc69a6d8f3174eba5a"
+        },
+        TestCase {
+            input: "2a459282195123ebc6cf5782ab611a11b9487706f7795e236df3a476404f4b8c1e9904e2dc5ef29c5e06b179b8649707928c3913d1e53164747f1fa9bba6eeaf8fb759d71e32adc8c611d061345882f1cdeee3ab4cab3554adb2e43f4b01c37b4546994b25f4dcd6c497bc206865643930157cb5b2f4f25be235fa223688535907efcc253bcd083021407ea09cb1c34684aa0c1849e7efe2d9af6938c46525af9e5afb4da6e5b83da4b61dc718672a8090549cbe5aadb44f5bc93a6b3fbdc2e6d32e2eaaae637465179ea17f23ad1e4f1ebc328e2c6dc90c302b74a1edbbb0676c136b269d70c41040a313af06ab291bf489d9700950b77f207c1fc41884799931b3bca8b93331a6e96b7a3f0a8bd24cdb64964c377e0512f36444bb0643a4e3ecb328194cd5428fd89ede167472a14a9bf5730aff1e3b2c708de96eff1ebaaf63beb75f9c7d8034d6e5471e8f8a1f7efce37793a958e134619c19c54d3d42645f7a7263f25471fbaae8be3ea2fbd34ec6d7aacd7d5680948c3cd9a837c9c469a88f600d95829f4d1e4e4a5ef4ed4623c07815a1c33d9fb3b91333ff04eac92806a68a46cf2e9293f8bff466ce87fe66b46fbff7c238c7f9b2c92eb2fdc7d8084167f6f4e680d03301e5c33f78f1857d6863b1b8c36c7fce3e07d2a96a8979712079ae0023a1e3970165bfcf3a5463d2a4fdf1ca0e044f9a247528cd935734cb6d85ba53ceb95325c0eaf0ff5cd81ecb32e58917eb26bfc52dba3704bf5a927fee3220",
+            output: "cb1c691c87244c0caf733aacd427f83412cd48820b358c1b15dd9fadee54e5af"
+        },
+        TestCase {
+            input: "32659902674c94473a283be00835eb86339d394a189a87da41dad500db27da6b6a4753b2bb219c961a227d88c6df466ba2fc1e9a2d4c982db4398778c76714d5e9940da48bc3808f3c9989131a07683b8c29d6af336e9aee1dfa57d83c48a86f17146edec07869bb06550689ebf4788159ed0a921048b4a6e3e3ec272413bec15d8e1f6a40897fa0e11d9df223ef9fc270106249ae220fdc6ebdef6d6611805421ccc850f53ee9c836baf657a94005883b5a85def344d218264f07b2ea8714afcc941096c6ded0bb6bf5b8bf652fd15a21931c58c9f526e27363ddff98c0a25bc7af9f469ab35bffea948b333f042cc18a82cec0177f33c3bdbf185b580353de79e51e675b03b31e195f19ba1f063d44def0441dc52820426c2c61cf12974ec249fd3502f017ffa06220075ced7e2d6b86a52677ba3916e8e8726062aec5bc8ea1c18b1e4137680b2c9d002191b423bee8691bd7e0f93c3b9959bc1c14d5c5cbe8f7c9c336aa16e9de9faa12f3f048c66d04cb441eb2bbc5e8a91e052c0f9000856896f9b7ba30c1e2eead36fc7ac30a7d3ddfc65caaba0e3b292d26dfba46b5e2dc9bc9acadde1c9f52b2969299bd1281ddff65822b629cfba2928613200e73661b803afdcc4a817d9361389e975e67dfadd22a797bdaf991ddf42db18711c079ecec55925f9978e478612609bacd900172011c27e24bad639ffc24a23877278318872153aef6893ccb5b68b94b33154df7334375aadd3edbb35272cc7b672dec68faa62900873ded52f6049891b77f2d0311a84b19b73660e09d1f1998095c1da1edecfa9f741b5fd6db048dd68255085d43529279021d59ed853470d6863b7c8e07fcb0d1e6acfb1eb16f7f60bb1f46ce70493010e57930a3b4b8b87e065272f6f1dd31df057627f4214e58798b664e1e40960f2789d44ccacfb3dbd8b02a68a053976711f8034c1ed3a8",
+            output: "5ac9275e02543410359a3f364b2ae3b85763321fd6d374d13fe54314e5561b01"
+        },
+        TestCase {
+            input: "a65da8277a3b3738432bca9822d43b3d810cdad3b0ed2468d02bd269f1a416cd77392190c2dde8630eeb28a297bda786017abe9cf82f14751422ac9fff6322d5d9a33173db49792d3bc37fff501af667f7ca3dd335d028551e04039ef5a9d42a9443e1b80ea872fd945ad8999514ae4a29a35f60b0f7e971b67ae04d1ba1b53470c03847a3225c3ddf593a57aed3599661ae2d2bb1cddd2fa62c4a94b8704c5c35c33e08e2debe54e567ae21e27e7eb36593ae1c807a8ef8b5c1495b15412108aaf3fce4130520aa6e2d3bdf7b3ea609fdf9ea1c64258435aae2e58a7b3abda198f979c17dbe0aa74253e979bf3a5800f388ea11a7f7454c4e36270a3083a790c77cbe89693205b32880c0d8f79b1c000ee9b5e58f175ba7696616c17c45673cff25d1221f899836e95cc9e26a887a7115c4537e65ad4eacc319ba98a9a8860c089cbc76e7ea4c984d900b80622afbbbd1c0cdc670e3a4c523f81c77fed38b6aa988876b097da8411cc48e9b25a826460a862aa3fadfe75952aa4347c2effebdac9138ebcc6c34991e9f5b19fc2b847a87be72ff49c99ecf19d837ee3e23686cd760d9dd7adc78091bca79e42fdb9bc0120faec1a6ca52913e2a0156ba9850e1f39d712859f7fdf7daedf0e206dff67e7121e5d1590a8a068947a8657d753e83c7f009b6b2e54acc24afc9fdc9601a1d6d9d1f17aab0ce96c4d83405d1e3baba1dffa86ecccee7f1c1b80b1bbf859106ce2b647ae1e4a6a9b584ae1dfc0a4deebb755638f1d95dcc79b1be263177e2a05c72bde545d09ba726f41d9547117e876af81bfc672e33c71442eb05675d9552df1b313d1f9934f9ddd08955fa21d6edf23000a277f6f149591299a0a96032861ecdc96bb76afa05a2bffb445d61dc891bc70c13695920b911cad0df3fa842a3e2318c57556974343f69794cb8fa18c1ad624835857e4781041198aa705c4d11f3ef82e941be2aee7a770e54521312fe6facbaf1138eee08fa90fae986a5d93719aeb30ac292a49c1d91bf4574d553a92a4a6c305ab09db6bbeffd84c7aa707f1c1628a0220d6ba4ee5e960566686228a6e766d8a30dddf30ed5aa637c949950c3d0e894a7560670b6879a7d70f3c7e5ab29aed236cc3527bdea076fec8add12d784fbcf9a",
+            output: "68f62c418a6b97026cc70f6abf8419b671ee373709fa13074e37bd39f0a50fcb"
+        },
+    ];
+}
diff --git a/hashes/src/sha512/crypto.rs b/hashes/src/sha512/crypto.rs
index 6bf4f5ce26..a86d962edf 100644
--- a/hashes/src/sha512/crypto.rs
+++ b/hashes/src/sha512/crypto.rs
@@ -174,6 +174,7 @@ impl HashEngine {
         round!(d, e, f, g, h, a, b, c, 0x597f299cfc657e2a, w[13], w[11], w[6], w[14]);
         round!(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faec, w[14], w[12], w[7], w[15]);
         round!(b, c, d, e, f, g, h, a, 0x6c44198c4a475817, w[15], w[13], w[8], w[0]);
+        let _ = w[15]; // silence "unnecessary assignment" lint in macro
 
         self.h[0] = self.h[0].wrapping_add(a);
         self.h[1] = self.h[1].wrapping_add(b);
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index 0f73f328e0..b5fbc610aa 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -4,10 +4,8 @@
 
 use internals::slice::SliceExt;
 
-#[cfg(bench)]
-mod benches;
 mod crypto;
-#[cfg(bench)]
+#[cfg(test)]
 mod tests;
 
 use core::cmp;
@@ -40,7 +38,7 @@ impl Hash {
         e.input(&(8 * n_bytes_hashed).to_be_bytes());
         debug_assert_eq!(incomplete_block_len(&e), 0);
 
-        Hash(e.midstate())
+        Self(e.midstate())
     }
 
     /// Finalize a hash engine to produce a hash.
@@ -101,7 +99,7 @@ impl HashEngine {
     /// Constructs a new hash engine suitable for use constructing a `sha512_256::HashEngine`.
     #[rustfmt::skip]
     pub(crate) const fn sha512_256() -> Self {
-        HashEngine {
+        Self {
             h: [
                 0x22312194fc2bf72c, 0x9f555fa3c84c64c2, 0x2393b86b6f53b151, 0x963877195940eabd,
                 0x96283ee2a88effe3, 0xbe5e1e2553863992, 0x2b0199fc2c85b8aa, 0x0eb72ddc81c52ca2,
@@ -114,7 +112,7 @@ impl HashEngine {
     /// Constructs a new hash engine suitable for constructing a `sha384::HashEngine`.
     #[rustfmt::skip]
     pub(crate) const fn sha384() -> Self {
-        HashEngine {
+        Self {
             h: [
                 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
                 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4,
diff --git a/hashes/src/sha512/tests.rs b/hashes/src/sha512/tests.rs
index ecf78582b2..4d982fd9e6 100644
--- a/hashes/src/sha512/tests.rs
+++ b/hashes/src/sha512/tests.rs
@@ -97,7 +97,7 @@ fn sha512_serde() {
         0x0b, 0x2d, 0x8a, 0x60, 0x0b, 0xdf, 0x4c, 0x0c,
     ];
 
-    let hash = sha512::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+    let hash = sha512::Hash::from_byte_array(HASH_BYTES);
     assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
     assert_tokens(
         &hash.readable(),
diff --git a/hashes/src/sha512_256/mod.rs b/hashes/src/sha512_256/mod.rs
index 291eac9f78..1ce6f65790 100644
--- a/hashes/src/sha512_256/mod.rs
+++ b/hashes/src/sha512_256/mod.rs
@@ -20,7 +20,7 @@ impl Hash {
     pub fn from_engine(e: HashEngine) -> Self {
         let mut ret = [0; 32];
         ret.copy_from_slice(&sha512::Hash::from_engine(e.0).as_byte_array()[..32]);
-        Hash(ret)
+        Self(ret)
     }
 }
 
@@ -142,40 +142,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{sha512_256, Hash, HashEngine};
-
-    #[bench]
-    pub fn sha512_256_10(bh: &mut Bencher) {
-        let mut engine = sha512_256::Hash::engine();
-        let bytes = [1u8; 10];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha512_256_1k(bh: &mut Bencher) {
-        let mut engine = sha512_256::Hash::engine();
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha512_256_64k(bh: &mut Bencher) {
-        let mut engine = sha512_256::Hash::engine();
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/src/siphash24/mod.rs b/hashes/src/siphash24/mod.rs
index 61f3dcf054..d65585dd59 100644
--- a/hashes/src/siphash24/mod.rs
+++ b/hashes/src/siphash24/mod.rs
@@ -34,7 +34,7 @@ macro_rules! compress {
     }};
 }
 
-/// Load an integer of the desired type from a byte stream, in LE order. Uses
+/// Loads an integer of the desired type from a byte stream, in LE order. Uses
 /// `copy_nonoverlapping` to let the compiler generate the most efficient way
 /// to load it from a possibly unaligned address.
 ///
@@ -77,8 +77,8 @@ pub struct HashEngine {
 impl HashEngine {
     /// Constructs a new SipHash24 engine with keys.
     #[inline]
-    pub const fn with_keys(k0: u64, k1: u64) -> HashEngine {
-        HashEngine {
+    pub const fn with_keys(k0: u64, k1: u64) -> Self {
+        Self {
             k0,
             k1,
             bytes_hashed: 0,
@@ -132,7 +132,7 @@ impl crate::HashEngine for HashEngine {
                 return;
             } else {
                 self.state.v3 ^= self.tail;
-                HashEngine::c_rounds(&mut self.state);
+                Self::c_rounds(&mut self.state);
                 self.state.v0 ^= self.tail;
                 self.ntail = 0;
             }
@@ -147,7 +147,7 @@ impl crate::HashEngine for HashEngine {
             let mi = unsafe { load_int_le!(msg, i, u64) };
 
             self.state.v3 ^= mi;
-            HashEngine::c_rounds(&mut self.state);
+            Self::c_rounds(&mut self.state);
             self.state.v0 ^= mi;
 
             i += 8;
@@ -168,7 +168,7 @@ impl Hash {
 
     /// Produces a hash from the current state of a given engine.
     #[cfg(not(hashes_fuzz))]
-    pub fn from_engine(e: HashEngine) -> Self { Hash::from_u64(Hash::from_engine_to_u64(e)) }
+    pub fn from_engine(e: HashEngine) -> Self { Self::from_u64(Self::from_engine_to_u64(e)) }
 
     #[cfg(hashes_fuzz)]
     pub fn from_engine(e: HashEngine) -> Self {
@@ -177,17 +177,17 @@ impl Hash {
     }
 
     /// Hashes the given data with an engine with the provided keys.
-    pub fn hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> Hash {
+    pub fn hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> Self {
         let mut engine = HashEngine::with_keys(k0, k1);
         engine.input(data);
-        Hash::from_engine(engine)
+        Self::from_engine(engine)
     }
 
     /// Hashes the given data directly to u64 with an engine with the provided keys.
     pub fn hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64 {
         let mut engine = HashEngine::with_keys(k0, k1);
         engine.input(data);
-        Hash::from_engine_to_u64(engine)
+        Self::from_engine_to_u64(engine)
     }
 
     /// Produces a hash as `u64` from the current state of a given engine.
@@ -207,18 +207,14 @@ impl Hash {
         state.v0 ^ state.v1 ^ state.v2 ^ state.v3
     }
 
-    /// Returns the (little endian) 64-bit integer representation of the hash value.
-    #[deprecated(since = "0.15.0", note = "use `to_u64` instead")]
-    pub fn as_u64(&self) -> u64 { self.to_u64() }
-
     /// Returns the (little endian) 64-bit integer representation of the hash value.
     pub fn to_u64(self) -> u64 { u64::from_le_bytes(self.0) }
 
     /// Constructs a new hash from its (little endian) 64-bit integer representation.
-    pub fn from_u64(hash: u64) -> Hash { Hash(hash.to_le_bytes()) }
+    pub fn from_u64(hash: u64) -> Self { Self(hash.to_le_bytes()) }
 }
 
-/// Load an u64 using up to 7 bytes of a byte slice.
+/// Loads a u64 using up to 7 bytes of a byte slice.
 ///
 /// Unsafe because: unchecked indexing at `start..start+len`.
 #[inline]
@@ -333,52 +329,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(bench)]
-mod benches {
-    use test::Bencher;
-
-    use crate::{siphash24, Hash, HashEngine};
-
-    #[bench]
-    pub fn siphash24_1ki(bh: &mut Bencher) {
-        let mut engine = siphash24::HashEngine::with_keys(0, 0);
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn siphash24_64ki(bh: &mut Bencher) {
-        let mut engine = siphash24::HashEngine::with_keys(0, 0);
-        let bytes = [1u8; 65536];
-        bh.iter(|| {
-            engine.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn siphash24_1ki_hash(bh: &mut Bencher) {
-        let k0 = 0x_07_06_05_04_03_02_01_00;
-        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            let _ = siphash24::Hash::hash_with_keys(k0, k1, &bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn siphash24_1ki_hash_u64(bh: &mut Bencher) {
-        let k0 = 0x_07_06_05_04_03_02_01_00;
-        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
-        let bytes = [1u8; 1024];
-        bh.iter(|| {
-            let _ = siphash24::Hash::hash_to_u64_with_keys(k0, k1, &bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/hashes/tests/api.rs b/hashes/tests/api.rs
index a85eb55476..387b316d01 100644
--- a/hashes/tests/api.rs
+++ b/hashes/tests/api.rs
@@ -2,24 +2,24 @@
 
 //! Test the API surface of `units`.
 //!
-//! The point of these tests are to check the API surface as opposed to test the API functionality.
+//! The point of these tests is to check the API surface as opposed to test the API functionality.
 //!
 //! ref: <https://rust-lang.github.io/api-guidelines/about.html>
 
 #![allow(dead_code)]
 #![allow(unused_imports)]
 // Exclude lints we don't think are valuable.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 // Import using module style e.g., `sha256::Hash`.
 use bitcoin_hashes::{
     hash160, hash_newtype, hkdf, hmac, ripemd160, sha1, sha256, sha256d, sha256t, sha256t_tag,
-    sha384, sha512, sha512_256, siphash24, FromSliceError, Hash, HashEngine,
+    sha384, sha3_256, sha512, sha512_256, siphash24, Hash, HashEngine,
 };
 // Import using type alias style e.g., `Sha256`.
 use bitcoin_hashes::{
-    Hash160, Hkdf, Hmac, HmacEngine, Ripemd160, Sha1, Sha256, Sha256d, Sha256t, Sha384, Sha512,
-    Sha512_256, Siphash24,
+    Hash160, Hkdf, Hmac, HmacEngine, Ripemd160, Sha1, Sha256, Sha256d, Sha256t, Sha384, Sha3_256,
+    Sha512, Sha512_256, Siphash24,
 };
 
 // Arbitrary midstate value; taken from as sha256t unit tests.
@@ -56,6 +56,7 @@ struct Hashes<T: Hash> {
     j: sha512::Hash,
     k: sha512_256::Hash,
     l: siphash24::Hash,
+    m: sha3_256::Hash,
 }
 
 impl Hashes<Sha256> {
@@ -65,7 +66,7 @@ impl Hashes<Sha256> {
         let tagged = TaggedHash::from_byte_array(Sha256t::<Tag>::hash(&[]).to_byte_array());
         let siphash = Siphash24::from_engine(siphash24::HashEngine::with_keys(0, 0));
 
-        Hashes {
+        Self {
             a: Hash160::hash(&[]),
             // b: hkdf,
             c: hmac,
@@ -78,6 +79,7 @@ impl Hashes<Sha256> {
             j: Sha512::hash(&[]),
             k: Sha512_256::hash(&[]),
             l: siphash,
+            m: Sha3_256::hash(&[]),
         }
     }
 }
@@ -98,11 +100,12 @@ struct Engines {
     i: sha512::HashEngine,
     j: sha512_256::HashEngine,
     k: siphash24::HashEngine,
+    l: sha3_256::HashEngine,
 }
 
 impl Engines {
     fn new_sha256() -> Self {
-        Engines {
+        Self {
             a: hash160::HashEngine::new(),
             b: hmac::HmacEngine::<sha256::HashEngine>::new(&[]),
             c: ripemd160::HashEngine::new(),
@@ -114,6 +117,7 @@ impl Engines {
             i: sha512::HashEngine::new(),
             j: sha512_256::HashEngine::new(),
             k: siphash24::HashEngine::with_keys(0, 0),
+            l: sha3_256::HashEngine::new(),
         }
     }
 }
@@ -148,6 +152,7 @@ struct Default {
     g: sha384::HashEngine,
     h: sha512::HashEngine,
     i: sha512_256::HashEngine,
+    j: sha3_256::HashEngine,
 }
 
 /// Hash types that require a key.
@@ -160,7 +165,6 @@ struct Keyed<T: Hash> {
 // These derives are the policy of `rust-bitcoin` not Rust API guidelines.
 #[derive(Debug, Clone, PartialEq, Eq)] // All public types implement Debug (C-DEBUG).
 struct Errors {
-    a: FromSliceError,
     b: hkdf::MaxLengthError,
     c: sha256::MidstateError,
 }
@@ -196,7 +200,7 @@ fn api_all_non_error_types_have_non_empty_debug() {
     let t = Hashes::<Sha256>::new_sha256();
     check_debug!(t; a, c, d, e, f, g, h, i, j, k, l);
 
-    // This tests `Debug` on `Hkdf` but not for all `T: GeneralHash`.
+    // This tests `Debug` on `Hkdf` but not for all `HashEngine` types.
     let t = Hkdf::<sha256::HashEngine>::new(&[], &[]);
     let debug = format!("{:?}", t);
     assert!(!debug.is_empty());
diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index dccff1714a..716bf3d31a 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -6,11 +6,11 @@
 
 #![cfg(feature = "hex")]
 // Exclude lints we don't think are valuable.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 use bitcoin_hashes::{
-    hash160, ripemd160, sha1, sha256, sha256d, sha256t, sha384, sha512, sha512_256, siphash24,
-    HashEngine as _, HmacEngine,
+    hash160, ripemd160, sha1, sha256, sha256d, sha256t, sha384, sha3_256, sha512, sha512_256,
+    siphash24, HashEngine as _, HmacEngine,
 };
 
 const DATA: &str = "arbitrary data to hash as a regression test";
@@ -36,6 +36,7 @@ impl_regression_test! {
     regression_sha256, sha256, "d291c6c5a07fa1d9315cdae090ebe14169fbe0a219cd55a48d0d2104eab6ec51";
     regression_sha256d, sha256d, "93a743b022290bde3233a619b21aaebe06c5cf5cc959464c41be35711e37731b";
     regression_sha384, sha384, "f545bd83d297978d47a7f26b858a54188499dfb4d7d570a6a2362c765031d57a29d7e002df5e34d184e70b65a4f47153";
+    regression_sha3_256, sha3_256, "9479c957c295f4e42a31dbd571062610c2c3435310b27a9548b83c0b45f4c9b3";
     regression_sha512, sha512, "057d0a37e9e0ac9a93acde0752748da059a27bcf946c7af00692ac1a95db8d21f965f40af22efc4710f100f8d3e43f79f77b1f48e1e400a95b7344b7bc0dfd10";
     regression_sha512_256, sha512_256, "e204244c429b5bca037a2a8a6e7ed8a42b808ceaff182560840bb8c5c8e9a2ec";
 }
diff --git a/internals/CHANGELOG.md b/internals/CHANGELOG.md
index f2b097554c..249b7dfe2e 100644
--- a/internals/CHANGELOG.md
+++ b/internals/CHANGELOG.md
@@ -1,3 +1,12 @@
+# 0.4.2 - 2025-12-08
+
+- Move `impl_array_newtype` to internals [#5334](https://github.com/rust-bitcoin/rust-bitcoin/pull/5334)
+
+# 0.4.1 - 2024-10-18
+
+- Bump MSRV to Rust 1.74.0 [#4926](https://github.com/rust-bitcoin/rust-bitcoin/pull/4926)
+- Add `hex-conservative` dependency
+
 # 0.4.0 - 2024-09-18
 
 - Introduce `ToU64` trait [#2929](https://github.com/rust-bitcoin/rust-bitcoin/pull/2929)
diff --git a/internals/Cargo.toml b/internals/Cargo.toml
index 374fe62d79..ce81656206 100644
--- a/internals/Cargo.toml
+++ b/internals/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin-internals"
-version = "0.4.0"
+version = "0.4.2"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>", "The Rust Bitcoin developers"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
@@ -10,7 +10,7 @@ categories = ["cryptography::cryptocurrencies", "no-std"]
 keywords = ["internal"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
@@ -22,7 +22,7 @@ test-serde = ["serde", "serde_json", "bincode"]
 
 [dependencies]
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
-serde = { version = "1.0.103", default-features = false, optional = true }
+serde = { version = "1.0.195", default-features = false, optional = true }
 
 # Don't enable these directly, use `test-serde` feature instead.
 serde_json = { version = "1.0.68", optional = true }
@@ -34,5 +34,5 @@ bincode = { version = "1.3.1", optional = true }
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
+[lints]
+workspace = true
diff --git a/internals/build.rs b/internals/build.rs
index fff95c4b98..05e9fa9804 100644
--- a/internals/build.rs
+++ b/internals/build.rs
@@ -1,5 +1,5 @@
 // Exclude lints we don't think are valuable.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 const MAX_USED_VERSION: u64 = 80;
 
@@ -7,7 +7,7 @@ use std::io;
 
 fn main() {
     let rustc = std::env::var_os("RUSTC");
-    let rustc = rustc.as_ref().map(std::path::Path::new).unwrap_or_else(|| "rustc".as_ref());
+    let rustc = rustc.as_ref().map_or_else(|| "rustc".as_ref(), std::path::Path::new);
     let output = std::process::Command::new(rustc)
         .arg("--version")
         .output()
@@ -15,9 +15,7 @@ fn main() {
     assert!(output.status.success(), "{:?} -- version returned non-zero exit code", rustc);
     let stdout = String::from_utf8(output.stdout).expect("rustc produced non-UTF-8 output");
     let version_prefix = "rustc ";
-    if !stdout.starts_with(version_prefix) {
-        panic!("unexpected rustc output: {}", stdout);
-    }
+    assert!(stdout.starts_with(version_prefix), "unexpected rustc output: {}", stdout);
 
     let version = &stdout[version_prefix.len()..];
     let end = version.find(&[' ', '-'] as &[_]).unwrap_or(version.len());
@@ -32,7 +30,7 @@ fn main() {
         .expect("invalid Rust minor version");
 
     let msrv = std::env::var("CARGO_PKG_RUST_VERSION").unwrap();
-    let mut msrv = msrv.split(".");
+    let mut msrv = msrv.split('.');
     let msrv_major = msrv.next().unwrap();
     assert_eq!(msrv_major, "1", "unexpected Rust major version");
     let msrv_minor = msrv.next().unwrap().parse::<u64>().unwrap();
@@ -51,10 +49,10 @@ fn write_macro(mut macro_file: impl io::Write, msrv_minor: u64, minor: u64) -> i
     writeln!(macro_file, "/// Example:")?;
     writeln!(macro_file, "/// ```")?;
     writeln!(macro_file, "/// bitcoin_internals::rust_version! {{")?;
-    writeln!(macro_file, "///     if >= 1.70 {{")?;
-    writeln!(macro_file, "///         println!(\"This is Rust 1.70+\");")?;
+    writeln!(macro_file, "///     if >= 1.78 {{")?;
+    writeln!(macro_file, "///         println!(\"This is Rust 1.78+\");")?;
     writeln!(macro_file, "///     }} else {{")?;
-    writeln!(macro_file, "///         println!(\"This is Rust < 1.70\");")?;
+    writeln!(macro_file, "///         println!(\"This is Rust < 1.78\");")?;
     writeln!(macro_file, "///     }}")?;
     writeln!(macro_file, "/// }}")?;
     writeln!(macro_file, "/// ```")?;
@@ -75,7 +73,7 @@ fn write_macro(mut macro_file: impl io::Write, msrv_minor: u64, minor: u64) -> i
         writeln!(macro_file, "        $($if_yes)*")?;
         writeln!(macro_file, "    }};")?;
     }
-    for version in (minor + 1)..(MAX_USED_VERSION + 1) {
+    for version in (minor + 1)..=MAX_USED_VERSION {
         writeln!(
             macro_file,
             "    (if >= 1.{} {{ $($if_yes:tt)* }} $(else {{ $($if_no:tt)* }})?) => {{",
diff --git a/internals/contrib/extra_lints.sh b/internals/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/internals/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/internals/src/array.rs b/internals/src/array.rs
index 4142212b31..4891d91df5 100644
--- a/internals/src/array.rs
+++ b/internals/src/array.rs
@@ -23,7 +23,7 @@ pub trait ArrayExt {
     ///
     /// Fails to compile if the array is empty.
     ///
-    /// Note that this method's name is intentionally shadowing the `std`'s `first` method which
+    /// Note that this method's name intentionally shadows the `std`'s `first` method which
     /// returns `Option`. The rationale is that given the known length of the array, we always know
     /// that this will not return `None` so trying to keep the `std` method around is pointless.
     /// Importing the trait will also cause compile failures - that's also intentional to expose
@@ -44,7 +44,7 @@ pub trait ArrayExt {
     ///
     /// Fails to compile if the array is empty.
     ///
-    /// Note that this method's name is intentionally shadowing the `std`'s `split_first` method which
+    /// Note that this method's name intentionally shadows the `std`'s `split_first` method which
     /// returns `Option`. The rationale is that given the known length of the array, we always know
     /// that this will not return `None` so trying to keep the `std` method around is pointless.
     /// Importing the trait will also cause compile failures - that's also intentional to expose
@@ -58,7 +58,7 @@ pub trait ArrayExt {
     ///
     /// Fails to compile if the array is empty.
     ///
-    /// Note that this method's name is intentionally shadowing the `std`'s `split_last` method which
+    /// Note that this method's name intentionally shadows the `std`'s `split_last` method which
     /// returns `Option`. The rationale is that given the known length of the array, we always know
     /// that this will not return `None` so trying to keep the `std` method around is pointless.
     /// Importing the trait will also cause compile failures - that's also intentional to expose
@@ -77,7 +77,7 @@ impl<const N: usize, T> ArrayExt for [T; N] {
 
     fn sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN] {
         #[allow(clippy::let_unit_value)]
-        let _ = Hack::<N, OFFSET, LEN>::IS_VALID_RANGE;
+        let () = Hack::<N, OFFSET, LEN>::IS_VALID_RANGE;
 
         self[OFFSET..(OFFSET + LEN)].try_into().expect("this is also compiler-checked above")
     }
@@ -86,7 +86,7 @@ impl<const N: usize, T> ArrayExt for [T; N] {
         &self,
     ) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT]) {
         #[allow(clippy::let_unit_value)]
-        let _ = Hack2::<N, LEFT, RIGHT>::IS_FULL_RANGE;
+        let () = Hack2::<N, LEFT, RIGHT>::IS_FULL_RANGE;
 
         (self.sub_array::<0, LEFT>(), self.sub_array::<LEFT, RIGHT>())
     }
diff --git a/internals/src/array_vec.rs b/internals/src/array_vec.rs
index 76d0490d5f..0ea6001d11 100644
--- a/internals/src/array_vec.rs
+++ b/internals/src/array_vec.rs
@@ -12,8 +12,6 @@ pub use safety_boundary::ArrayVec;
 mod safety_boundary {
     use core::mem::MaybeUninit;
 
-    use crate::const_tools::cond_const;
-
     /// A growable contiguous collection backed by array.
     #[derive(Copy)]
     pub struct ArrayVec<T: Copy, const CAP: usize> {
@@ -43,18 +41,21 @@ mod safety_boundary {
             Self { len: slice.len(), data }
         }
 
-        // from_raw_parts is const-unstable until 1.64
-        cond_const! {
-            /// Returns a reference to the underlying data.
-            pub const(in 1.64) fn as_slice(&self) -> &[T] {
-                let ptr = &self.data as *const _ as *const T;
-                unsafe { core::slice::from_raw_parts(ptr, self.len) }
-            }
+        /// Returns a reference to the underlying data.
+        pub const fn as_slice(&self) -> &[T] {
+            // transmute needed; see https://github.com/rust-lang/rust/issues/63569
+            // SAFETY: self.len is chosen such that everything is initialized up to len,
+            //  and MaybeUninit<T> has the same representation as T.
+            let ptr = self.data.as_ptr().cast::<T>();
+            unsafe { core::slice::from_raw_parts(ptr, self.len) }
         }
 
         /// Returns a mutable reference to the underlying data.
         pub fn as_mut_slice(&mut self) -> &mut [T] {
-            unsafe { &mut *(&mut self.data[..self.len] as *mut _ as *mut [T]) }
+            // SAFETY: self.len is chosen such that everything is initialized up to len,
+            //  and MaybeUninit<T> has the same representation as T.
+            let ptr = self.data.as_mut_ptr().cast::<T>();
+            unsafe { core::slice::from_raw_parts_mut(ptr, self.len) }
         }
 
         /// Adds an element into `self`.
@@ -68,6 +69,23 @@ mod safety_boundary {
             self.len += 1;
         }
 
+        /// Removes the last element, returning it.
+        ///
+        /// # Returns
+        ///
+        /// None if the `ArrayVec` is empty.
+        pub fn pop(&mut self) -> Option<T> {
+            if self.len > 0 {
+                self.len -= 1;
+                // SAFETY: All elements in 0..len are initialized
+                let res = self.data[self.len];
+                self.data[self.len] = MaybeUninit::uninit();
+                Some(unsafe { res.assume_init() })
+            } else {
+                None
+            }
+        }
+
         /// Copies and appends all elements from `slice` into `self`.
         ///
         /// # Panics
@@ -77,7 +95,10 @@ mod safety_boundary {
             let new_len = self.len.checked_add(slice.len()).expect("integer/buffer overflow");
             assert!(new_len <= CAP, "buffer overflow");
             // SAFETY: MaybeUninit<T> has the same layout as T
-            let slice = unsafe { &*(slice as *const _ as *const [MaybeUninit<T>]) };
+            let slice = unsafe {
+                let ptr = slice.as_ptr();
+                core::slice::from_raw_parts(ptr.cast::<MaybeUninit<T>>(), slice.len())
+            };
             self.data[self.len..new_len].copy_from_slice(slice);
             self.len = new_len;
         }
@@ -93,6 +114,7 @@ impl<T: Copy, const CAP: usize> Default for ArrayVec<T, CAP> {
 /// Because we avoid copying the uninitialized part of the array this copies the value faster than
 /// memcpy.
 #[allow(clippy::non_canonical_clone_impl)]
+#[allow(clippy::expl_impl_clone_on_copy)]
 impl<T: Copy, const CAP: usize> Clone for ArrayVec<T, CAP> {
     fn clone(&self) -> Self { Self::from_slice(self) }
 }
@@ -136,7 +158,7 @@ impl<T: Copy + PartialEq, const CAP: usize, const LEN: usize> PartialEq<ArrayVec
 }
 
 impl<T: Copy + Ord, const CAP: usize> Ord for ArrayVec<T, CAP> {
-    fn cmp(&self, other: &ArrayVec<T, CAP>) -> core::cmp::Ordering { (**self).cmp(&**other) }
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering { (**self).cmp(&**other) }
 }
 
 impl<T: Copy + PartialOrd, const CAP1: usize, const CAP2: usize> PartialOrd<ArrayVec<T, CAP2>>
@@ -169,14 +191,14 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "assertion failed")]
     fn overflow_push() {
         let mut av = ArrayVec::<_, 0>::new();
         av.push(42);
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "buffer overflow")]
     fn overflow_extend() {
         let mut av = ArrayVec::<_, 0>::new();
         av.extend_from_slice(&[42]);
@@ -212,7 +234,7 @@ mod verification {
         }
     }
 
-    #[kani::unwind(16)] // One grater than 15.
+    #[kani::unwind(16)] // One greater than 15.
     #[kani::proof]
     fn no_out_of_bounds_upto_cap() {
         const CAP: usize = 15;
diff --git a/internals/src/compact_size.rs b/internals/src/compact_size.rs
index a343f3c16a..473f31ee16 100644
--- a/internals/src/compact_size.rs
+++ b/internals/src/compact_size.rs
@@ -18,7 +18,7 @@ use crate::ToU64;
 pub const MAX_ENCODABLE_VALUE: u64 = 0x0200_0000;
 
 /// The maximum length of an encoding.
-const MAX_ENCODING_SIZE: usize = 9;
+pub const MAX_ENCODING_SIZE: usize = 9;
 
 /// Returns the number of bytes used to encode this `CompactSize` value.
 ///
@@ -44,7 +44,7 @@ pub const fn encoded_size_const(value: u64) -> usize {
     match value {
         0..=0xFC => 1,
         0xFD..=0xFFFF => 3,
-        0x10000..=0xFFFFFFFF => 5,
+        0x10000..=0xFFFF_FFFF => 5,
         _ => 9,
     }
 }
@@ -63,15 +63,14 @@ pub fn encode(value: impl ToU64) -> ArrayVec<u8, MAX_ENCODING_SIZE> {
             res.push(0xFD);
             res.extend_from_slice(&v.to_le_bytes());
         }
-        0x10000..=0xFFFFFFFF => {
+        0x10000..=0xFFFF_FFFF => {
             let v = value as u32; // Cast ok because of match.
             res.push(0xFE);
             res.extend_from_slice(&v.to_le_bytes());
         }
         _ => {
-            let v = value;
             res.push(0xFF);
-            res.extend_from_slice(&v.to_le_bytes());
+            res.extend_from_slice(&value.to_le_bytes());
         }
     }
     res
@@ -89,16 +88,12 @@ pub fn encode(value: impl ToU64) -> ArrayVec<u8, MAX_ENCODING_SIZE> {
 /// * Panics in release mode if the `slice` does not contain a valid minimal compact size encoding.
 /// * Panics in debug mode if the encoding is not minimal (referred to as "non-canonical" in Core).
 pub fn decode_unchecked(slice: &mut &[u8]) -> u64 {
-    if slice.is_empty() {
-        panic!("tried to decode an empty slice");
-    }
+    assert!(!slice.is_empty(), "tried to decode an empty slice");
 
     match slice[0] {
         0xFF => {
             const SIZE: usize = 9;
-            if slice.len() < SIZE {
-                panic!("slice too short, expected at least 9 bytes");
-            };
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 9 bytes");
 
             let mut bytes = [0_u8; SIZE - 1];
             bytes.copy_from_slice(&slice[1..SIZE]);
@@ -110,9 +105,7 @@ pub fn decode_unchecked(slice: &mut &[u8]) -> u64 {
         }
         0xFE => {
             const SIZE: usize = 5;
-            if slice.len() < SIZE {
-                panic!("slice too short, expected at least 5 bytes");
-            };
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 5 bytes");
 
             let mut bytes = [0_u8; SIZE - 1];
             bytes.copy_from_slice(&slice[1..SIZE]);
@@ -124,9 +117,7 @@ pub fn decode_unchecked(slice: &mut &[u8]) -> u64 {
         }
         0xFD => {
             const SIZE: usize = 3;
-            if slice.len() < SIZE {
-                panic!("slice too short, expected at least 3 bytes");
-            };
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 3 bytes");
 
             let mut bytes = [0_u8; SIZE - 1];
             bytes.copy_from_slice(&slice[1..SIZE]);
@@ -219,8 +210,10 @@ mod tests {
     check_decode! {
         // 3 byte encoding.
         decode_from_3_byte_slice_lower_bound, 3, 0xFD, [0xFD, 0xFD, 0x00];
+        decode_from_3_byte_slice_three_over_lower_bound, 3, 0x0100, [0xFD, 0x00, 0x01];
         decode_from_3_byte_slice_endianness, 3, 0xABCD, [0xFD, 0xCD, 0xAB];
         decode_from_3_byte_slice_upper_bound, 3, 0xFFFF, [0xFD, 0xFF, 0xFF];
+
         // 5 byte encoding.
         decode_from_5_byte_slice_lower_bound, 5, 0x0001_0000, [0xFE, 0x00, 0x00, 0x01, 0x00];
         decode_from_5_byte_slice_endianness, 5, 0x0123_4567, [0xFE, 0x67, 0x45, 0x23, 0x01];
@@ -238,14 +231,14 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "tried to decode an empty slice")]
     fn decode_from_empty_slice_panics() {
         let mut slice = [].as_slice();
         let _ = decode_unchecked(&mut slice);
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "slice too short")]
     // Non-minimal is referred to as non-canonical in Core (`bitcoin/src/serialize.h`).
     fn decode_non_minimal_panics() {
         let mut slice = [0xFE, 0xCD, 0xAB].as_slice();
diff --git a/internals/src/const_casts.rs b/internals/src/const_casts.rs
new file mode 100644
index 0000000000..03ca18da76
--- /dev/null
+++ b/internals/src/const_casts.rs
@@ -0,0 +1,18 @@
+//! Const-compatible integer casting functions.
+//!
+//! This module provides explicit, const-compatible functions for integer type conversions
+//! that would normally be done using the [`Into`] trait. Since trait methods cannot be used
+//! in `const` contexts, these functions serve as alternatives that make conversion intent
+//! clear while maintaining compile-time evaluation capabilities.
+
+/// Converts `u16` to `u64`
+pub const fn u16_to_u64(value: u16) -> u64 { value as u64 }
+
+/// Converts `u32` to `u64`
+pub const fn u32_to_u64(value: u32) -> u64 { value as u64 }
+
+/// Converts `i16` to `i64`
+pub const fn i16_to_i64(value: i16) -> i64 { value as i64 }
+
+/// Converts `u16` to `u32`
+pub const fn u16_to_u32(value: u16) -> u32 { value as u32 }
diff --git a/internals/src/const_tools.rs b/internals/src/const_tools.rs
index bd4c723267..70e2b8852f 100644
--- a/internals/src/const_tools.rs
+++ b/internals/src/const_tools.rs
@@ -41,7 +41,7 @@ macro_rules! concat_bytes_to_arr {
         let mut output = [0u8; $len];
         let mut i = 0;
         while i < a.len() {
-            output[i] = $a[i];
+            output[i] = a[i];
             i += 1;
         }
         while i < a.len() + b.len() {
diff --git a/internals/src/error/input_string.rs b/internals/src/error/input_string.rs
index b544c73452..b6708b906a 100644
--- a/internals/src/error/input_string.rs
+++ b/internals/src/error/input_string.rs
@@ -68,6 +68,10 @@ impl InputString {
     ///     }
     /// }
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the write to the formatter fails.
     pub fn unknown_variant<T>(&self, what: &T, f: &mut fmt::Formatter) -> fmt::Result
     where
         T: fmt::Display + ?Sized,
@@ -122,7 +126,7 @@ mod storage {
     }
 
     impl From<&str> for Storage {
-        fn from(_value: &str) -> Self { Storage }
+        fn from(_value: &str) -> Self { Self }
     }
 
     pub(super) fn cannot_parse<W>(_: &Storage, what: &W, f: &mut fmt::Formatter) -> fmt::Result
diff --git a/internals/src/error/parse_error.rs b/internals/src/error/parse_error.rs
index 4a26427065..b81954a4e4 100644
--- a/internals/src/error/parse_error.rs
+++ b/internals/src/error/parse_error.rs
@@ -1,6 +1,6 @@
 //! Contains helpers for parsing-related errors.
 
-/// Creates an error type intended for string parsing errors.
+/// Constructs an error type intended for string parsing errors.
 ///
 /// The resulting error type has two fields: `input` and `source`. The type of `input` is
 /// [`InputString`](super::InputString), the type of `source` is specified as the second argument
@@ -13,8 +13,8 @@
 ///
 /// * `name` - the name of the error type
 /// * `source` - the type of the source type
-/// * `subject` - English description of the type being parsed (e.g. "a bitcoin amount")
-/// * `derive` - list of derives to add
+/// * `subject` - the english description of the type being parsed (e.g. "a bitcoin amount")
+/// * `derive` - the list of derives to add
 #[macro_export]
 macro_rules! parse_error_type {
     ($vis:vis $name:ident, $source:ty, $subject:expr $(, $derive:path)* $(,)?) => {
diff --git a/internals/src/lib.rs b/internals/src/lib.rs
index e86dfda690..2425927e70 100644
--- a/internals/src/lib.rs
+++ b/internals/src/lib.rs
@@ -1,21 +1,15 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin Internal
+//! Rust Bitcoin Internal
 //!
 //! This crate is only meant to be used internally by crates in the
 //! [rust-bitcoin](https://github.com/rust-bitcoin) ecosystem.
 
 #![no_std]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
-// Exclude lints we don't think are valuable.
-#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
-#![allow(clippy::manual_range_contains)] // More readable than clippy's format.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -55,6 +49,7 @@ pub mod wrap_debug;
 #[cfg(feature = "serde")]
 #[macro_use]
 pub mod serde;
+pub mod const_casts;
 
 /// A conversion trait for unsigned integer types smaller than or equal to 64-bits.
 ///
diff --git a/internals/src/macros.rs b/internals/src/macros.rs
index ce0d412bcf..1119fcde1d 100644
--- a/internals/src/macros.rs
+++ b/internals/src/macros.rs
@@ -15,12 +15,9 @@ macro_rules! const_assert {
     }
 }
 
-/// Adds an implementation of `pub fn to_hex(&self) -> String` if `alloc` feature is enabled.
+/// Adds an implementation of `pub fn to_hex(&self) -> String`.
 ///
 /// The added function allocates a `String` then calls through to [`core::fmt::LowerHex`].
-///
-/// Note: Calling this macro assumes that the calling crate has an `alloc` feature that also activates the
-/// `alloc` crate. Calling this macro without the `alloc` feature enabled is a no-op.
 #[macro_export]
 macro_rules! impl_to_hex_from_lower_hex {
     ($t:ident, $hex_len_fn:expr) => {
@@ -38,7 +35,7 @@ macro_rules! impl_to_hex_from_lower_hex {
     };
 }
 
-/// Creates a transparent wrapper around an inner type and soundly implements reference casts.
+/// Constructs a transparent wrapper around an inner type and soundly implements reference casts.
 ///
 /// This macro takes care of several issues related to newtypes that need to allow casting their
 /// inner types to themselves:
@@ -247,3 +244,121 @@ macro_rules! _emit_alloc {
 macro_rules! _emit_alloc {
     ($($tokens:tt)*) => {};
 }
+
+/// Implements standard array methods for a given wrapper type.
+#[macro_export]
+macro_rules! impl_array_newtype {
+    ($thing:ident, $ty:ty, $len:literal) => {
+        impl $thing {
+            /// Constructs a new `Self` by wrapping `bytes`.
+            #[inline]
+            pub fn from_byte_array(bytes: [u8; $len]) -> Self { Self(bytes) }
+
+            /// Returns a reference the underlying byte array.
+            #[inline]
+            pub fn as_byte_array(&self) -> &[u8; $len] { &self.0 }
+
+            /// Returns the underlying byte array.
+            #[inline]
+            pub fn to_byte_array(self) -> [u8; $len] {
+                // We rely on `Copy` being implemented for $thing so conversion
+                // methods use the correct Rust naming conventions.
+                fn check_copy<T: Copy>() {}
+                check_copy::<$thing>();
+
+                self.0
+            }
+
+            /// Copies the underlying bytes into a new `Vec`.
+            #[inline]
+            pub fn to_vec(self) -> alloc::vec::Vec<u8> { self.0.to_vec() }
+
+            /// Returns a slice of the underlying bytes.
+            #[inline]
+            pub fn as_bytes(&self) -> &[u8] { &self.0 }
+
+            /// Converts the object to a raw pointer.
+            #[inline]
+            pub fn as_ptr(&self) -> *const $ty {
+                let &$thing(ref dat) = self;
+                dat.as_ptr()
+            }
+
+            /// Converts the object to a mutable raw pointer.
+            #[inline]
+            pub fn as_mut_ptr(&mut self) -> *mut $ty {
+                let &mut $thing(ref mut dat) = self;
+                dat.as_mut_ptr()
+            }
+
+            /// Returns the length of the object as an array.
+            #[inline]
+            pub fn len(&self) -> usize { $len }
+
+            /// Returns whether the object, as an array, is empty. Always false.
+            #[inline]
+            pub fn is_empty(&self) -> bool { false }
+        }
+
+        impl<'a> core::convert::From<[$ty; $len]> for $thing {
+            fn from(data: [$ty; $len]) -> Self { $thing(data) }
+        }
+
+        impl<'a> core::convert::From<&'a [$ty; $len]> for $thing {
+            fn from(data: &'a [$ty; $len]) -> Self { $thing(*data) }
+        }
+
+        impl<'a> core::convert::TryFrom<&'a [$ty]> for $thing {
+            type Error = core::array::TryFromSliceError;
+
+            fn try_from(data: &'a [$ty]) -> core::result::Result<Self, Self::Error> {
+                use core::convert::TryInto;
+
+                Ok($thing(data.try_into()?))
+            }
+        }
+
+        impl AsRef<[$ty; $len]> for $thing {
+            fn as_ref(&self) -> &[$ty; $len] { &self.0 }
+        }
+
+        impl AsMut<[$ty; $len]> for $thing {
+            fn as_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
+        }
+
+        impl AsRef<[$ty]> for $thing {
+            fn as_ref(&self) -> &[$ty] { &self.0 }
+        }
+
+        impl AsMut<[$ty]> for $thing {
+            fn as_mut(&mut self) -> &mut [$ty] { &mut self.0 }
+        }
+
+        impl core::borrow::Borrow<[$ty; $len]> for $thing {
+            fn borrow(&self) -> &[$ty; $len] { &self.0 }
+        }
+
+        impl core::borrow::BorrowMut<[$ty; $len]> for $thing {
+            fn borrow_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
+        }
+
+        // The following two are valid because `[T; N]: Borrow<[T]>`
+        impl core::borrow::Borrow<[$ty]> for $thing {
+            fn borrow(&self) -> &[$ty] { &self.0 }
+        }
+
+        impl core::borrow::BorrowMut<[$ty]> for $thing {
+            fn borrow_mut(&mut self) -> &mut [$ty] { &mut self.0 }
+        }
+
+        impl<I> core::ops::Index<I> for $thing
+        where
+            [$ty]: core::ops::Index<I>,
+        {
+            type Output = <[$ty] as core::ops::Index<I>>::Output;
+
+            #[inline]
+            fn index(&self, index: I) -> &Self::Output { &self.0[index] }
+        }
+    };
+}
diff --git a/internals/src/script.rs b/internals/src/script.rs
index 89e2a326ec..e95e875e9b 100644
--- a/internals/src/script.rs
+++ b/internals/src/script.rs
@@ -6,6 +6,10 @@
 ///
 /// A script push data instruction includes the length of the data being pushed, this function reads
 /// that length from an iterator (encoded in either 1, 2, or 4 bytes).
+///
+/// # Errors
+///
+/// Returns an error if the iterator does not contain enough bytes to read the length.
 // We internally use implementation based on iterator so that it automatically advances as needed.
 pub fn read_push_data_len(
     data: &mut core::slice::Iter<'_, u8>,
@@ -52,7 +56,7 @@ mod tests {
         let bytes = [0x01, 0x23, 0x45, 0x67];
         let want = u32::from_le_bytes([0x01, 0x23, 0x45, 0x67]);
         let got = read_push_data_len(&mut bytes.iter(), PushDataLenLen::Four).unwrap();
-        assert_eq!(got, want as usize)
+        assert_eq!(got, want as usize);
     }
 
     #[test]
@@ -60,7 +64,7 @@ mod tests {
         let bytes = [0x01, 0x23];
         let want = u16::from_le_bytes([0x01, 0x23]);
         let got = read_push_data_len(&mut bytes.iter(), PushDataLenLen::Two).unwrap();
-        assert_eq!(got, want as usize)
+        assert_eq!(got, want as usize);
     }
 
     #[test]
@@ -68,6 +72,6 @@ mod tests {
         let bytes = [0x01];
         let want = 0x01;
         let got = read_push_data_len(&mut bytes.iter(), PushDataLenLen::One).unwrap();
-        assert_eq!(got, want as usize)
+        assert_eq!(got, want as usize);
     }
 }
diff --git a/internals/src/serde.rs b/internals/src/serde.rs
index 7c25cfae49..bb52e9ef34 100644
--- a/internals/src/serde.rs
+++ b/internals/src/serde.rs
@@ -18,6 +18,10 @@ pub trait IntoDeError: Sized {
     ///
     /// If the error type doesn't contain enough information to explain the error precisely this
     /// should return `Err(self)` allowing the caller to use its information instead.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Err(self)` if the error cannot be converted to a deserializer error.
     fn try_into_de_error<E>(self, expected: Option<&dyn de::Expected>) -> Result<E, Self>
     where
         E: de::Error,
@@ -27,7 +31,7 @@ pub trait IntoDeError: Sized {
 }
 
 mod impls {
-    use super::*;
+    use super::{de, IntoDeError};
 
     impl IntoDeError for core::convert::Infallible {
         fn into_de_error<E: de::Error>(self, _expected: Option<&dyn de::Expected>) -> E {
@@ -124,7 +128,7 @@ macro_rules! serde_string_impl {
 }
 
 /// A combination macro where the human-readable serialization is done like
-/// serde_string_impl and the non-human-readable impl is done as a struct.
+/// `serde_string_impl` and the non-human-readable impl is done as a struct.
 #[macro_export]
 macro_rules! serde_struct_human_string_impl {
     ($name:ident, $expecting:literal, $($fe:ident),*) => (
diff --git a/internals/src/slice.rs b/internals/src/slice.rs
index 6c91a4d2b4..ddecd1fc7c 100644
--- a/internals/src/slice.rs
+++ b/internals/src/slice.rs
@@ -58,7 +58,7 @@ impl<T> SliceExt for [T] {
 
     fn bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item]) {
         #[allow(clippy::let_unit_value)]
-        let _ = Hack::<N>::IS_NONZERO;
+        let () = Hack::<N>::IS_NONZERO;
 
         let chunks_count = self.len() / N;
         let total_left_len = chunks_count * N;
@@ -77,7 +77,7 @@ impl<T> SliceExt for [T] {
         &mut self,
     ) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
         #[allow(clippy::let_unit_value)]
-        let _ = Hack::<N>::IS_NONZERO;
+        let () = Hack::<N>::IS_NONZERO;
 
         let chunks_count = self.len() / N;
         let total_left_len = chunks_count * N;
diff --git a/io/CHANGELOG.md b/io/CHANGELOG.md
index 6f0d38d92b..1cb9e4b405 100644
--- a/io/CHANGELOG.md
+++ b/io/CHANGELOG.md
@@ -1,3 +1,15 @@
+# 0.3.0 - 2025-12-01
+
+* Bump MSRV to Rust `1.74` [#4926](https://github.com/rust-bitcoin/rust-bitcoin/pull/)
+* Make traits dyn compatible [#5249](https://github.com/rust-bitcoin/rust-bitcoin/pull/5249)
+* Invert dependency between `io` and `hashes` [#3961](https://github.com/rust-bitcoin/rust-bitcoin/pull/3961)
+* Introduce `encode_to_writer` for `Write` trait [#5214](https://github.com/rust-bitcoin/rust-bitcoin/pull/5214)
+* Add consensus decoding functions [#5212](https://github.com/rust-bitcoin/rust-bitcoin/pull/5212)
+* Remove assertion in `Cursor` when reading past end [#5062](https://github.com/rust-bitcoin/rust-bitcoin/pull/5062)
+* Enable features in internals crate [#4890](https://github.com/rust-bitcoin/rust-bitcoin/pull/4890)
+* Make `io::Error` `Sync` [#3920](https://github.com/rust-bitcoin/rust-bitcoin/pull/3920)
+* Use `get_ref` / `get_mut` API [#3855](https://github.com/rust-bitcoin/rust-bitcoin/pull/3855)
+
 # 0.2.0 - 2024-09-18
 
 * Add blanket impl of io traits for `&mut T` [#3188](https://github.com/rust-bitcoin/rust-bitcoin/pull/3188)
@@ -5,6 +17,11 @@
 * Bump MSRV to Rust `v1.63.0` [#3100](https://github.com/rust-bitcoin/rust-bitcoin/pull/3100)
 * Remove blanket trait impls [#2453](https://github.com/rust-bitcoin/rust-bitcoin/pull/2453)
 
+# 0.1.3 - 2024-11-02
+
+* Backport IO improvements [#3181](https://github.com/rust-bitcoin/rust-bitcoin/pull/3181)
+  (Original PR: [#3176](https://github.com/rust-bitcoin/rust-bitcoin/pull/3176))
+
 # 0.1.2 - 2024-03-14
 
 * Implement `From<core::convert::Infallible>` for Errors [#2516](https://github.com/rust-bitcoin/rust-bitcoin/pull/2516)
diff --git a/io/Cargo.toml b/io/Cargo.toml
index 07b38baa61..2649a69d45 100644
--- a/io/Cargo.toml
+++ b/io/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin-io"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Matt Corallo <birchneutea@mattcorallo.com>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
@@ -10,21 +10,22 @@ categories = ["no-std"]
 keywords = [ "io", "no-std" ]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "hashes?/std"]
-alloc = ["hashes?/alloc"]
+std = ["alloc", "encoding/std", "hashes?/std", "internals/std"]
+alloc = ["encoding/alloc", "hashes?/alloc", "internals/alloc"]
 
 [dependencies]
-internals = { package = "bitcoin-internals", path = "../internals" }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.1" }
+encoding = { package = "bitcoin-consensus-encoding", path = "../consensus_encoding", version = "=1.0.0-rc.2", default-features = false }
 
-hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = false, optional = true }
+hashes = { package = "bitcoin_hashes", path = "../hashes", version = "0.18.0", default-features = false, optional = true }
 
 [dev-dependencies]
-hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = false, features = ["hex"] }
+hashes = { package = "bitcoin_hashes", path = "../hashes", version = "0.18.0", default-features = false, features = ["hex"] }
 
 [package.metadata.docs.rs]
 all-features = true
@@ -32,3 +33,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
 unexpected_cfgs = { level = "deny" }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
diff --git a/io/contrib/extra_lints.sh b/io/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/io/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index 816820a2a5..371dde8b13 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -35,12 +35,12 @@ impl<T> FromStd<T> {
 
     /// Returns a reference to the wrapped value.
     #[inline]
-    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
+    #[deprecated(since = "0.3.0", note = "use `get_ref()` instead")]
     pub fn inner(&self) -> &T { &self.0 }
 
     /// Returns a mutable reference to the wrapped value.
     #[inline]
-    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
+    #[deprecated(since = "0.3.0", note = "use `get_mut()` instead")]
     pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
 }
 
@@ -253,40 +253,20 @@ macro_rules! impl_our {
     };
 }
 
-rust_version! {
-    if >= 1.72 {
-        impl_our! {
-            impl<R: std::io::Read> Read for std::io::BufReader<R> where R: ?Sized
-        }
-
-        impl_our! {
-            impl<R: std::io::Read> BufRead for std::io::BufReader<R> where R: ?Sized
-        }
-
-        impl_our! {
-            impl<W: std::io::Write> Write for std::io::BufWriter<W> where W: ?Sized
-        }
-
-        impl_our! {
-            impl<W: std::io::Write> Write for std::io::LineWriter<W> where W: ?Sized
-        }
-    } else {
-        impl_our! {
-            impl<R: std::io::Read> Read for std::io::BufReader<R>
-        }
+impl_our! {
+    impl<R: std::io::Read> Read for std::io::BufReader<R> where R: ?Sized
+}
 
-        impl_our! {
-            impl<R: std::io::Read> BufRead for std::io::BufReader<R>
-        }
+impl_our! {
+    impl<R: std::io::Read> BufRead for std::io::BufReader<R> where R: ?Sized
+}
 
-        impl_our! {
-            impl<W: std::io::Write> Write for std::io::BufWriter<W>
-        }
+impl_our! {
+    impl<W: std::io::Write> Write for std::io::BufWriter<W> where W: ?Sized
+}
 
-        impl_our! {
-            impl<W: std::io::Write> Write for std::io::LineWriter<W>
-        }
-    }
+impl_our! {
+    impl<W: std::io::Write> Write for std::io::LineWriter<W> where W: ?Sized
 }
 
 impl std::io::Write for super::Sink {
@@ -344,25 +324,21 @@ impl_our! {
     impl BufRead for std::io::Empty
 }
 
-rust_version! {
-    if >= 1.73 {
-        impl_our! {
-            impl Write for std::io::Empty
-        }
+impl_our! {
+    impl Write for std::io::Empty
+}
 
-        // No idea why &Empty impls Write but not Read + BufRead
-        impl_our! {
-            impl Write for &'_ std::io::Empty
-        }
+// No idea why &Empty impls Write but not Read + BufRead
+impl_our! {
+    impl Write for &'_ std::io::Empty
+}
 
-        impl_our! {
-            impl Read for std::sync::Arc<std::fs::File>
-        }
+impl_our! {
+    impl Read for std::sync::Arc<std::fs::File>
+}
 
-        impl_our! {
-            impl Write for std::sync::Arc<std::fs::File>
-        }
-    }
+impl_our! {
+    impl Write for std::sync::Arc<std::fs::File>
 }
 
 impl_our! {
@@ -469,7 +445,7 @@ impl_our! {
     impl Write for std::process::ChildStdin
 }
 
-// No ide why other &ChildStd* are not implemented
+// No idea why other &ChildStd* are not implemented
 impl_our! {
     impl Write for &'_ std::process::ChildStdin
 }
diff --git a/io/src/error.rs b/io/src/error.rs
index a79725cf2b..61a574d543 100644
--- a/io/src/error.rs
+++ b/io/src/error.rs
@@ -24,7 +24,7 @@ pub struct Error {
 impl Error {
     /// Constructs a new I/O error.
     #[cfg(feature = "std")]
-    pub fn new<E>(kind: ErrorKind, error: E) -> Error
+    pub fn new<E>(kind: ErrorKind, error: E) -> Self
     where
         E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
     {
@@ -33,7 +33,7 @@ impl Error {
 
     /// Constructs a new I/O error.
     #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub fn new<E: sealed::IntoBoxDynDebug>(kind: ErrorKind, error: E) -> Error {
+    pub fn new<E: sealed::IntoBoxDynDebug>(kind: ErrorKind, error: E) -> Self {
         Self { kind, _not_unwind_safe: core::marker::PhantomData, error: Some(error.into()) }
     }
 
@@ -54,7 +54,7 @@ impl Error {
 }
 
 impl From<ErrorKind> for Error {
-    fn from(kind: ErrorKind) -> Error {
+    fn from(kind: ErrorKind) -> Self {
         Self {
             kind,
             _not_unwind_safe: core::marker::PhantomData,
@@ -84,7 +84,7 @@ impl std::error::Error for Error {
 
 #[cfg(feature = "std")]
 impl From<std::io::Error> for Error {
-    fn from(o: std::io::Error) -> Error {
+    fn from(o: std::io::Error) -> Self {
         Self {
             kind: ErrorKind::from_std(o.kind()),
             _not_unwind_safe: core::marker::PhantomData,
@@ -95,9 +95,9 @@ impl From<std::io::Error> for Error {
 
 #[cfg(feature = "std")]
 impl From<Error> for std::io::Error {
-    fn from(o: Error) -> std::io::Error {
+    fn from(o: Error) -> Self {
         if let Some(err) = o.error {
-            std::io::Error::new(o.kind.to_std(), err)
+            Self::new(o.kind.to_std(), err)
         } else {
             o.kind.to_std().into()
         }
diff --git a/io/src/hash.rs b/io/src/hash.rs
index 859f035b73..8fa4ce12b2 100644
--- a/io/src/hash.rs
+++ b/io/src/hash.rs
@@ -30,7 +30,6 @@ macro_rules! impl_write {
         }
     }
 }
-pub(crate) use impl_write;
 
 impl_write!(
     hash160::HashEngine,
diff --git a/io/src/lib.rs b/io/src/lib.rs
index e5bf1e1eb4..15201bca32 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin I/O Library
+//! Rust Bitcoin I/O Library
 //!
 //! The [`std::io`] module is not exposed in `no-std` Rust so building `no-std` applications which
 //! require reading and writing objects via standard traits is not generally possible. Thus, this
@@ -14,8 +14,6 @@
 //! `github.com/rust-bitcoin/rust-bitcoin/bitcoin/examples/` directory.
 
 #![cfg_attr(not(feature = "std"), no_std)]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![doc(test(attr(warn(unused))))]
@@ -24,7 +22,7 @@
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -43,11 +41,12 @@ mod hash;
 use alloc::vec::Vec;
 use core::cmp;
 
-#[cfg(feature = "std")]
-pub use bridge::{FromStd, ToStd};
+use encoding::{Decodable, Decoder, Encoder};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use self::error::{Error, ErrorKind};
+#[cfg(feature = "std")]
+pub use self::bridge::{FromStd, ToStd};
 #[cfg(feature = "hashes")]
 pub use self::hash::hash_reader;
 
@@ -85,7 +84,12 @@ pub trait Read {
 
     /// Constructs a new adapter which will read at most `limit` bytes.
     #[inline]
-    fn take(&mut self, limit: u64) -> Take<Self> { Take { reader: self, remaining: limit } }
+    fn take(self, limit: u64) -> Take<Self>
+    where
+        Self: Sized,
+    {
+        Take { reader: self, remaining: limit }
+    }
 
     /// Attempts to read up to limit bytes from the reader, allocating space in `buf` as needed.
     ///
@@ -126,12 +130,12 @@ pub trait BufRead: Read {
 ///
 /// Created by calling `[Read::take]`.
 #[derive(Debug)]
-pub struct Take<'a, R: Read + ?Sized> {
-    reader: &'a mut R,
+pub struct Take<R> {
+    reader: R,
     remaining: u64,
 }
 
-impl<R: Read + ?Sized> Take<'_, R> {
+impl<R: Read> Take<R> {
     /// Reads all bytes until EOF from the underlying reader into `buf`.
     ///
     /// Allocates space in `buf` as needed.
@@ -159,7 +163,7 @@ impl<R: Read + ?Sized> Take<'_, R> {
     }
 }
 
-impl<R: Read + ?Sized> Read for Take<'_, R> {
+impl<R: Read> Read for Take<R> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         let len = cmp::min(buf.len(), self.remaining.try_into().unwrap_or(buf.len()));
@@ -170,7 +174,7 @@ impl<R: Read + ?Sized> Read for Take<'_, R> {
 }
 
 // Impl copied from Rust stdlib.
-impl<R: BufRead + ?Sized> BufRead for Take<'_, R> {
+impl<R: BufRead> BufRead for Take<R> {
     #[inline]
     fn fill_buf(&mut self) -> Result<&[u8]> {
         // Don't call into inner reader at all at EOF because it may still block
@@ -193,7 +197,7 @@ impl<R: BufRead + ?Sized> BufRead for Take<'_, R> {
     }
 }
 
-impl<T: Read> Read for &'_ mut T {
+impl<T: Read + ?Sized> Read for &'_ mut T {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> { (**self).read(buf) }
 
@@ -201,7 +205,7 @@ impl<T: Read> Read for &'_ mut T {
     fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { (**self).read_exact(buf) }
 }
 
-impl<T: BufRead> BufRead for &'_ mut T {
+impl<T: BufRead + ?Sized> BufRead for &'_ mut T {
     #[inline]
     fn fill_buf(&mut self) -> Result<&[u8]> { (**self).fill_buf() }
 
@@ -228,7 +232,7 @@ impl BufRead for &[u8] {
     fn consume(&mut self, amount: usize) { *self = &self[amount..] }
 }
 
-/// Wraps an in memory reader providing the `position` function.
+/// Wraps an in memory buffer providing `position` functionality for read and write.
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct Cursor<T> {
     inner: T,
@@ -238,9 +242,9 @@ pub struct Cursor<T> {
 impl<T: AsRef<[u8]>> Cursor<T> {
     /// Constructs a new `Cursor` by wrapping `inner`.
     #[inline]
-    pub const fn new(inner: T) -> Self { Cursor { inner, pos: 0 } }
+    pub const fn new(inner: T) -> Self { Self { inner, pos: 0 } }
 
-    /// Returns the position read up to thus far.
+    /// Returns the position read or written up to thus far.
     #[inline]
     pub const fn position(&self) -> u64 { self.pos }
 
@@ -249,7 +253,7 @@ impl<T: AsRef<[u8]>> Cursor<T> {
     /// This method allows seeking within the wrapped memory by setting the position.
     ///
     /// Note that setting a position that is larger than the buffer length will cause reads to
-    /// succeed by reading zero bytes.
+    /// succeed by reading zero bytes. Further, writes will be no-op zero length writes.
     #[inline]
     pub fn set_position(&mut self, position: u64) { self.pos = position; }
 
@@ -275,7 +279,7 @@ impl<T: AsRef<[u8]>> Cursor<T> {
     ///
     /// This is the whole wrapped buffer, including the bytes already read.
     #[inline]
-    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
+    #[deprecated(since = "0.3.0", note = "use `get_ref()` instead")]
     pub fn inner(&self) -> &T { &self.inner }
 }
 
@@ -299,14 +303,26 @@ impl<T: AsRef<[u8]>> BufRead for Cursor<T> {
     #[inline]
     fn fill_buf(&mut self) -> Result<&[u8]> {
         let inner: &[u8] = self.inner.as_ref();
-        Ok(&inner[self.pos as usize..])
+        let pos = self.pos.min(inner.len() as u64) as usize;
+        Ok(&inner[pos..])
     }
 
     #[inline]
-    fn consume(&mut self, amount: usize) {
-        assert!(amount <= self.inner.as_ref().len());
-        self.pos += amount as u64;
+    fn consume(&mut self, amount: usize) { self.pos = self.pos.saturating_add(amount as u64); }
+}
+
+impl<T: AsMut<[u8]>> Write for Cursor<T> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        let write_slice = self.inner.as_mut();
+        let pos = cmp::min(self.pos, write_slice.len() as u64);
+        let amt = (&mut write_slice[(pos as usize)..]).write(buf)?;
+        self.pos += amt as u64;
+        Ok(amt)
     }
+
+    #[inline]
+    fn flush(&mut self) -> Result<()> { Ok(()) }
 }
 
 /// A generic trait describing an output stream.
@@ -408,11 +424,191 @@ pub const fn from_std<T>(std_io: T) -> FromStd<T> { FromStd::new(std_io) }
 #[inline]
 pub fn from_std_mut<T>(std_io: &mut T) -> &mut FromStd<T> { FromStd::new_mut(std_io) }
 
+/// Encodes a consensus_encoding object to an I/O writer.
+pub fn encode_to_writer<T, W>(object: &T, mut writer: W) -> Result<()>
+where
+    T: encoding::Encodable + ?Sized,
+    W: Write,
+{
+    let mut encoder = object.encoder();
+    loop {
+        writer.write_all(encoder.current_chunk())?;
+        if !encoder.advance() {
+            break;
+        }
+    }
+    Ok(())
+}
+
+/// Decodes an object from a buffered reader.
+///
+/// # Performance
+///
+/// For unbuffered readers (like [`std::fs::File`] or [`std::net::TcpStream`]), consider wrapping
+/// your reader with [`std::io::BufReader`] in order to use this function. This avoids frequent
+/// small reads, which can significantly impact performance.
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+pub fn decode_from_read<T, R>(
+    mut reader: R,
+) -> core::result::Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: BufRead,
+{
+    let mut decoder = T::decoder();
+
+    loop {
+        let mut buffer = match reader.fill_buf() {
+            Ok(buffer) => buffer,
+            // Auto retry read for non-fatal error.
+            Err(error) if error.kind() == ErrorKind::Interrupted => continue,
+            Err(error) => return Err(ReadError::Io(error)),
+        };
+
+        if buffer.is_empty() {
+            // EOF, but still try to finalize the decoder.
+            return decoder.end().map_err(ReadError::Decode);
+        }
+
+        let original_len = buffer.len();
+        let need_more = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
+        let consumed = original_len - buffer.len();
+        reader.consume(consumed);
+
+        if !need_more {
+            return decoder.end().map_err(ReadError::Decode);
+        }
+    }
+}
+
+/// Decodes an object from an unbuffered reader using a fixed-size buffer.
+///
+/// For most use cases, prefer [`decode_from_read`] with a [`std::io::BufReader`].
+/// This function is only needed when you have an unbuffered reader which you
+/// cannot wrap. It will probably have worse performance.
+///
+/// # Buffer
+///
+/// Uses a fixed 4KB (4096 bytes) stack-allocated buffer that is reused across
+/// read operations. This size is a good balance between memory usage and
+/// system call efficiency for most use cases.
+///
+/// For different buffer sizes, use [`decode_from_read_unbuffered_with`].
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+pub fn decode_from_read_unbuffered<T, R>(
+    reader: R,
+) -> core::result::Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: Read,
+{
+    decode_from_read_unbuffered_with::<T, R, 4096>(reader)
+}
+
+/// Decodes an object from an unbuffered reader using a custom-sized buffer.
+///
+/// For most use cases, prefer [`decode_from_read`] with a [`std::io::BufReader`].
+/// This function is only needed when you have an unbuffered reader which you
+/// cannot wrap. It will probably have worse performance.
+///
+/// # Buffer
+///
+/// The `BUFFER_SIZE` parameter controls the intermediate buffer size used for
+/// reading. The buffer is allocated on the stack (not heap) and reused across
+/// read operations. Larger buffers reduce the number of system calls, but use
+/// more memory.
+///
+/// # Errors
+///
+/// Returns [`ReadError::Decode`] if the decoder encounters an error while parsing
+/// the data, or [`ReadError::Io`] if an I/O error occurs while reading.
+pub fn decode_from_read_unbuffered_with<T, R, const BUFFER_SIZE: usize>(
+    mut reader: R,
+) -> core::result::Result<T, ReadError<<T::Decoder as Decoder>::Error>>
+where
+    T: Decodable,
+    R: Read,
+{
+    let mut decoder = T::decoder();
+    let mut buffer = [0u8; BUFFER_SIZE];
+
+    while decoder.read_limit() > 0 {
+        // Only read what we need, up to buffer size.
+        let clamped_buffer = &mut buffer[..decoder.read_limit().min(BUFFER_SIZE)];
+        match reader.read(clamped_buffer) {
+            Ok(0) => {
+                // EOF, but still try to finalize the decoder.
+                return decoder.end().map_err(ReadError::Decode);
+            }
+            Ok(bytes_read) => {
+                if !decoder
+                    .push_bytes(&mut &clamped_buffer[..bytes_read])
+                    .map_err(ReadError::Decode)?
+                {
+                    return decoder.end().map_err(ReadError::Decode);
+                }
+            }
+            Err(ref e) if e.kind() == ErrorKind::Interrupted => {
+                // Auto retry read for non-fatal error.
+            }
+            Err(e) => return Err(ReadError::Io(e)),
+        }
+    }
+
+    decoder.end().map_err(ReadError::Decode)
+}
+
+/// An error that can occur when reading and decoding from a buffered reader.
+#[derive(Debug)]
+pub enum ReadError<D> {
+    /// An I/O error occurred while reading from the reader.
+    Io(Error),
+    /// The decoder encountered an error while parsing the data.
+    Decode(D),
+}
+
+impl<D: core::fmt::Display> core::fmt::Display for ReadError<D> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "I/O error: {}", e),
+            Self::Decode(e) => write!(f, "decode error: {}", e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<D> std::error::Error for ReadError<D>
+where
+    D: core::fmt::Debug + core::fmt::Display + std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Io(e) => Some(e),
+            Self::Decode(e) => Some(e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<D> From<Error> for ReadError<D> {
+    fn from(e: Error) -> Self { Self::Io(e) }
+}
+
 #[cfg(test)]
 mod tests {
     #[cfg(all(not(feature = "std"), feature = "alloc"))]
     use alloc::{string::ToString, vec};
 
+    use encoding::{ArrayDecoder, ArrayEncoder, UnexpectedEofError};
+
     use super::*;
 
     #[test]
@@ -517,4 +713,183 @@ mod tests {
         assert_eq!(read, 32);
         assert_eq!(data[0..32], v[0..32]);
     }
+
+    #[test]
+    fn cursor_fill_buf_past_end() {
+        let data = [1, 2, 3];
+        let mut cursor = Cursor::new(&data);
+        cursor.set_position(10);
+
+        let buf = cursor.fill_buf().unwrap();
+        assert!(buf.is_empty());
+    }
+
+    #[test]
+    fn cursor_write() {
+        let data = [0x78, 0x56, 0x34, 0x12];
+
+        let mut buf = [0_u8; 4];
+        let mut cursor = Cursor::new(&mut buf);
+        let amt = cursor.write(&data).unwrap();
+
+        assert_eq!(buf, data);
+        assert_eq!(amt, 4);
+    }
+
+    #[test]
+    fn cursor_offset_write() {
+        let data = [0x78, 0x56, 0x34, 0x12];
+
+        let mut buf = [0_u8; 4];
+        let mut cursor = Cursor::new(&mut buf);
+        cursor.set_position(2);
+        let amt = cursor.write(&data).unwrap();
+
+        assert_eq!(buf, [0, 0, 0x78, 0x56]);
+        assert_eq!(amt, 2);
+    }
+
+    #[test]
+    fn cursor_consume_past_end() {
+        let data = [1, 2, 3];
+        let mut cursor = Cursor::new(&data);
+        cursor.set_position(10);
+
+        cursor.consume(5);
+        assert_eq!(cursor.position(), 15);
+    }
+
+    // Simple test type that implements Encodable.
+    struct TestData(u32);
+
+    impl encoding::Encodable for TestData {
+        type Encoder<'s>
+            = ArrayEncoder<4>
+        where
+            Self: 's;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            ArrayEncoder::without_length_prefix(self.0.to_le_bytes())
+        }
+    }
+
+    #[test]
+    fn encode_io_writer() {
+        let data = TestData(0x1234_5678);
+
+        let mut buf = [0_u8; 4];
+        encode_to_writer(&data, buf.as_mut_slice()).unwrap();
+
+        assert_eq!(buf, [0x78, 0x56, 0x34, 0x12]);
+    }
+
+    #[derive(Debug, PartialEq)]
+    struct TestArray([u8; 4]);
+
+    impl Decodable for TestArray {
+        type Decoder = TestArrayDecoder;
+        fn decoder() -> Self::Decoder { TestArrayDecoder { inner: ArrayDecoder::new() } }
+    }
+
+    struct TestArrayDecoder {
+        inner: ArrayDecoder<4>,
+    }
+
+    impl Decoder for TestArrayDecoder {
+        type Output = TestArray;
+        type Error = UnexpectedEofError;
+
+        fn push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error> {
+            self.inner.push_bytes(bytes)
+        }
+
+        fn end(self) -> core::result::Result<Self::Output, Self::Error> {
+            self.inner.end().map(TestArray)
+        }
+
+        fn read_limit(&self) -> usize { self.inner.read_limit() }
+    }
+
+    #[test]
+    fn decode_from_read_success() {
+        let data = [1, 2, 3, 4];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn decode_from_read_unexpected_eof() {
+        let data = [1, 2, 3];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    fn decode_from_read_trait_object() {
+        let data = [1, 2, 3, 4];
+        let mut cursor = Cursor::new(&data);
+        // Test that we can pass a trait object (&mut dyn BufRead implements BufRead).
+        let reader: &mut dyn BufRead = &mut cursor;
+        let result: core::result::Result<TestArray, _> = decode_from_read(reader);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_from_read_by_reference() {
+        use crate::alloc::vec::Vec;
+
+        let data = [1, 2, 3, 4];
+        let mut cursor = Cursor::new(&data);
+        // Test that we can pass by reference (&mut T implements BufRead when T: BufRead).
+        let result: core::result::Result<TestArray, _> = decode_from_read(&mut cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+
+        let mut buf = Vec::new();
+        let _ = cursor.read_to_limit(&mut buf, 100);
+    }
+
+    #[test]
+    fn decode_from_read_unbuffered_success() {
+        let data = [1, 2, 3, 4];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn decode_from_read_unbuffered_unexpected_eof() {
+        let data = [1, 2, 3];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    fn decode_from_read_unbuffered_empty() {
+        let data = [];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(matches!(result, Err(ReadError::Decode(_))));
+    }
+
+    #[test]
+    fn decode_from_read_unbuffered_extra_data() {
+        let data = [1, 2, 3, 4, 5, 6];
+        let cursor = Cursor::new(&data);
+        let result: core::result::Result<TestArray, _> = decode_from_read_unbuffered(cursor);
+        assert!(result.is_ok());
+        let decoded = result.unwrap();
+        assert_eq!(decoded.0, [1, 2, 3, 4]);
+    }
 }
diff --git a/io/tests/api.rs b/io/tests/api.rs
index efc64f2e69..28be86a190 100644
--- a/io/tests/api.rs
+++ b/io/tests/api.rs
@@ -1,6 +1,6 @@
 //! Test the API surface of `io`.
 //!
-//! The point of these tests are to check the API surface as opposed to test the API functionality.
+//! The point of these tests is to check the API surface as opposed to test the API functionality.
 //!
 //! ref: <https://rust-lang.github.io/api-guidelines/about.html>
 
@@ -25,7 +25,7 @@ struct Enums {
 }
 
 impl Enums {
-    /// Creates an arbitrary `Enums` instance.
+    /// Constructs an arbitrary `Enums` instance.
     fn new() -> Self { Self { a: ERROR_KIND } }
 }
 
@@ -54,8 +54,8 @@ impl Structs {
 }
 
 #[derive(Debug)] // `Take` implements Debug (C-DEBUG).
-struct Taker<'a> {
-    a: Take<'a, Dummy>,
+struct Taker<Dummy> {
+    a: Take<Dummy>,
 }
 
 /// An arbitrary `Dummy` instance.
@@ -130,7 +130,7 @@ fn api_all_non_error_types_have_non_empty_debug() {
 }
 
 #[test]
-fn all_non_error_tyes_implement_send_sync() {
+fn all_non_error_types_implement_send_sync() {
     fn assert_send<T: Send>() {}
     fn assert_sync<T: Sync>() {}
 
@@ -142,3 +142,19 @@ fn all_non_error_tyes_implement_send_sync() {
     assert_send::<Errors>();
     assert_sync::<Errors>();
 }
+
+#[test]
+fn dyn_compatible() {
+    // Sanity check, these are all dyn compatible.
+    struct StdlibTraits {
+        p: Box<dyn std::io::Read>,
+        q: Box<dyn std::io::Write>,
+        r: Box<dyn std::io::BufRead>,
+    }
+    // If this builds then our three traits are dyn compatible also.
+    struct OurTraits {
+        p: Box<dyn Read>,
+        q: Box<dyn Write>,
+        r: Box<dyn BufRead>,
+    }
+}
diff --git a/justfile b/justfile
index e3e2d37e3f..299ff3a26a 100644
--- a/justfile
+++ b/justfile
@@ -1,61 +1,83 @@
 set positional-arguments
 
+# Once just v1.39.0 is widely deployed, simplify with the `read` function.
+NIGHTLY_VERSION := trim(shell('cat "$1"', justfile_directory() / "nightly-version"))
+
 alias ulf := update-lock-files
 
-default:
+_default:
   @just --list
 
-# Cargo build everything.
-build:
-  cargo build --workspace --all-targets --all-features
+# Run the given CI task using maintainer tools.
+[group('ci')]
+@ci task toolchain="stable" lock="recent":
+  {{justfile_directory()}}/contrib/ensure-maintainer-tools.sh
+  cp -f {{justfile_directory()}}/Cargo-{{lock}}.lock {{justfile_directory()}}/Cargo.lock
+  MAINTAINER_TOOLS_LOG_LEVEL=quiet rustup run {{toolchain}} {{justfile_directory()}}/.maintainer-tools/ci/run_task.sh {{task}}
 
-# Cargo check everything.
-check:
-  cargo check --workspace --all-targets --all-features
+# Test workspace with stable toolchain.
+[group('ci')]
+ci-stable: (ci "stable")
 
-# Lint everything.
-lint:
-  cargo +$(cat ./nightly-version) clippy --workspace --all-targets --all-features -- --deny warnings
-  # lint warnings get inhibited unless we use `--nocapture`
-  cargo test --quiet --workspace --doc -- --nocapture
+# Lint workspace.
+[group('ci')]
+ci-lint: (ci "lint" NIGHTLY_VERSION)
 
-# Run cargo fmt
-fmt:
-  cargo +$(cat ./nightly-version) fmt --all
+# Generate documentation.
+[group('ci')]
+ci-docs: (ci "docs")
 
-# Check the formatting
-format:
-  cargo +$(cat ./nightly-version) fmt --all --check
+# Generate documentation with nightly.
+[group('ci')]
+ci-docsrs: (ci "docsrs" NIGHTLY_VERSION)
 
-# Generate documentation.
-docsrs *flags:
-  RUSTDOCFLAGS="--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links" cargo +$(cat ./nightly-version) doc --all-features {{flags}}
+# Run benchmarks.
+[group('ci')]
+ci-bench: (ci "bench")
 
-# Quick and dirty CI useful for pre-push checks.
-sane: lint
-  cargo test --quiet --workspace --all-targets --no-default-features > /dev/null || exit 1
-  cargo test --quiet --workspace --all-targets > /dev/null || exit 1
-  cargo test --quiet --workspace --all-targets --all-features > /dev/null || exit 1
+# Quick workspace lint.
+@lint:
+  cargo +{{NIGHTLY_VERSION}} clippy --quiet --workspace --all-targets --all-features -- --deny warnings
 
-  # Make an attempt to catch feature gate problems in doctests
-  cargo test --manifest-path bitcoin/Cargo.toml --doc --no-default-features > /dev/null || exit 1
+# Quick workspace sanity check.
+@sane: lint
+  cargo test --quiet --workspace --all-targets --no-default-features
+  cargo test --quiet --workspace --all-targets --all-features
+
+# Format workspace.
+@fmt:
+  cargo +{{NIGHTLY_VERSION}} fmt --all
+
+# Generate documentation (accepts cargo doc args, e.g. --open).
+@docsrs *flags:
+  RUSTDOCFLAGS="--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links" cargo +{{NIGHTLY_VERSION}} doc --all-features {{flags}}
 
 # Check for API changes.
+[group('scripts')]
 check-api:
- contrib/check-for-api-changes.sh
+ {{justfile_directory()}}/contrib/check-for-api-changes.sh
 
 # Query the current API.
+[group('scripts')]
 @query-api crate command:
- contrib/api.sh $1 $2
+ {{justfile_directory()}}/contrib/api.sh $1 $2
 
 # Update the recent and minimal lock files.
+[group('scripts')]
 update-lock-files:
-  contrib/update-lock-files.sh
+ {{justfile_directory()}}/contrib/update-lock-files.sh
 
-# Install githooks
+# Install githooks.
+[group('scripts')]
 githooks-install:
-  ./contrib/copy-githooks.sh
+ {{justfile_directory()}}/contrib/copy-githooks.sh
 
-# Remove githooks
+# Remove githooks.
+[group('scripts')]
 githooks-remove:
-  ./contrib/copy-githooks.sh -r
+ {{justfile_directory()}}/contrib/copy-githooks.sh -r
+
+# Generate a dependency tree for workspace crates.
+[group('scripts')]
+gen-dep-tree:
+  {{justfile_directory()}}/contrib/gen-dep-tree.sh
diff --git a/maintainer-tools-version b/maintainer-tools-version
new file mode 100644
index 0000000000..f9a7d00fde
--- /dev/null
+++ b/maintainer-tools-version
@@ -0,0 +1 @@
+e7ad5b2aa5f742093d8e07d4a2a7d415254cf6f4
diff --git a/nightly-version b/nightly-version
index 8adb8e5801..fa9b5fe681 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-05-16
+nightly-2025-09-26
diff --git a/p2p/CHANGELOG.md b/p2p/CHANGELOG.md
new file mode 100644
index 0000000000..4c310ad4be
--- /dev/null
+++ b/p2p/CHANGELOG.md
@@ -0,0 +1,3 @@
+# 0.1.0 - 2025-05-27
+
+* Initial release of the `github.com/rust-bitcoin/rust-bitcoin/p2p` crate as `bitcoin-p2p-messages`.
diff --git a/p2p/Cargo.toml b/p2p/Cargo.toml
new file mode 100644
index 0000000000..40983ad290
--- /dev/null
+++ b/p2p/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "bitcoin-p2p-messages"
+version = "0.1.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+license = "CC0-1.0"
+repository = "https://github.com/rust-bitcoin/rust-bitcoin"
+description = "Peer-to-peer messages defined by the Bitcoin protocol"
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["bitcoin", "peer-to-peer"]
+readme = "README.md"
+edition = "2021"
+rust-version = "1.74.0"
+exclude = ["tests", "contrib"]
+
+[features]
+default = ["std"]
+std = ["encoding/std", "hashes/std", "hex/std", "internals/std", "io/std", "units/std", "bitcoin/std", "primitives/std"]
+arbitrary = ["dep:arbitrary", "bitcoin/arbitrary"]
+
+[dependencies]
+bitcoin = { path = "../bitcoin/", default-features = false }
+encoding = { package = "bitcoin-consensus-encoding", version = "=1.0.0-rc.2", path = "../consensus_encoding", default-features = false }
+hashes = { package = "bitcoin_hashes", version = "0.18.0", path = "../hashes", default-features = false }
+primitives = { package = "bitcoin-primitives", path = "../primitives", version = "=1.0.0-rc.1", default-features = false }
+hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
+internals = { package = "bitcoin-internals", path = "../internals", default-features = false }
+io = { package = "bitcoin-io", path = "../io", default-features = false }
+units = { package = "bitcoin-units", path = "../units", version = "=1.0.0-rc.3", default-features = false }
+
+arbitrary = { version = "1.4.1", optional = true }
+
+[dev-dependencies]
+hex_lit = "0.1.1"
+
+[[example]]
+name = "handshake"
+required-features = ["std"]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints]
+workspace = true
diff --git a/p2p/README.md b/p2p/README.md
new file mode 100644
index 0000000000..23d3f939fa
--- /dev/null
+++ b/p2p/README.md
@@ -0,0 +1,3 @@
+# Rust Bitcoin Peer to Peer Message Types
+
+This crate provides data types used in the Bitcoin peer-to-peer protocol.
diff --git a/p2p/contrib/extra_lints.sh b/p2p/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/p2p/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/p2p/contrib/test_vars.sh b/p2p/contrib/test_vars.sh
new file mode 100644
index 0000000000..701c4c89b0
--- /dev/null
+++ b/p2p/contrib/test_vars.sh
@@ -0,0 +1,14 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+#
+# disable verify unused vars, despite the fact that they are used when sourced
+# shellcheck disable=SC2034
+
+# Test all these features with "std" enabled.
+FEATURES_WITH_STD=""
+
+# Test all these features without "std" enabled.
+FEATURES_WITHOUT_STD="arbitrary"
+
+# Run these examples.
+EXAMPLES=""
diff --git a/bitcoin/examples/handshake.rs b/p2p/examples/handshake.rs
similarity index 65%
rename from bitcoin/examples/handshake.rs
rename to p2p/examples/handshake.rs
index 4382de02a7..d631b49fc5 100644
--- a/bitcoin/examples/handshake.rs
+++ b/p2p/examples/handshake.rs
@@ -1,11 +1,17 @@
-use std::io::{BufReader, Write};
+use std::io::BufReader;
 use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{env, process};
 
-use bitcoin::consensus::{encode, Decodable};
-use bitcoin::p2p::{self, address, message, message_network};
-use bitcoin::secp256k1::rand::Rng;
+use bitcoin_p2p_messages::message_network::{ClientSoftwareVersion, UserAgent, UserAgentVersion};
+use bitcoin_p2p_messages::{
+    self, address, message, message_network, Magic, ProtocolVersion, ServiceFlags,
+};
+
+const SOFTWARE_VERSION: ClientSoftwareVersion =
+    ClientSoftwareVersion::SemVer { major: 0, minor: 1, revision: 0 };
+const USER_AGENT_VERSION: UserAgentVersion = UserAgentVersion::new(SOFTWARE_VERSION);
+const SOFTWARE_NAME: &str = "rust-client";
 
 fn main() {
     // This example establishes a connection to a Bitcoin node, sends the initial
@@ -25,30 +31,31 @@ fn main() {
 
     let version_message = build_version_message(address);
 
-    let first_message =
-        message::RawNetworkMessage::new(bitcoin::Network::Bitcoin.magic(), version_message);
+    let first_message = message::RawNetworkMessage::new(Magic::BITCOIN, version_message);
 
     if let Ok(mut stream) = TcpStream::connect(address) {
         // Send the message
-        let _ = stream.write_all(encode::serialize(&first_message).as_slice());
+        encoding::encode_to_writer(&first_message, &mut stream).unwrap();
         println!("Sent version message");
 
         // Setup StreamReader
         let read_stream = stream.try_clone().unwrap();
         let mut stream_reader = BufReader::new(read_stream);
         loop {
-            // Loop an retrieve new messages
-            let reply = message::RawNetworkMessage::consensus_decode(&mut stream_reader).unwrap();
+            // Loop and retrieve new messages
+            let reply =
+                encoding::decode_from_read::<message::RawNetworkMessage, _>(&mut stream_reader)
+                    .unwrap();
             match reply.payload() {
                 message::NetworkMessage::Version(_) => {
                     println!("Received version message: {:?}", reply.payload());
 
                     let second_message = message::RawNetworkMessage::new(
-                        bitcoin::Network::Bitcoin.magic(),
+                        Magic::BITCOIN,
                         message::NetworkMessage::Verack,
                     );
 
-                    let _ = stream.write_all(encode::serialize(&second_message).as_slice());
+                    encoding::encode_to_writer(&second_message, &mut stream).unwrap();
                     println!("Sent verack message");
                 }
                 message::NetworkMessage::Verack => {
@@ -71,29 +78,34 @@ fn build_version_message(address: SocketAddr) -> message::NetworkMessage {
     // Building version message, see https://en.bitcoin.it/wiki/Protocol_documentation#version
     let my_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
 
+    // The version of the p2p protocol this client will use
+    let protocol_version = ProtocolVersion::BIP0031_VERSION;
+
     // "bitfield of features to be enabled for this connection"
-    let services = p2p::ServiceFlags::NONE;
+    let services = ServiceFlags::NONE;
 
     // "standard UNIX timestamp in seconds"
     let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time error").as_secs();
 
     // "The network address of the node receiving this message"
-    let addr_recv = address::Address::new(&address, p2p::ServiceFlags::NONE);
+    let addr_recv = address::Address::new(&address, ServiceFlags::NONE);
 
     // "The network address of the node emitting this message"
-    let addr_from = address::Address::new(&my_address, p2p::ServiceFlags::NONE);
+    let addr_from = address::Address::new(&my_address, ServiceFlags::NONE);
 
     // "Node random nonce, randomly generated every time a version packet is sent. This nonce is used to detect connections to self."
-    let nonce: u64 = secp256k1::rand::thread_rng().gen();
-
-    // "User Agent (0x00 if string is 0 bytes long)"
-    let user_agent = String::from("rust-example");
+    // Because this crate does not include the `rand` dependency, this is a fixed value.
+    let nonce: u64 = 42;
 
     // "The last block received by the emitting node"
     let start_height: i32 = 0;
 
+    // A formatted string describing the software in use.
+    let user_agent = UserAgent::new(SOFTWARE_NAME, &USER_AGENT_VERSION);
+
     // Construct the message
     message::NetworkMessage::Version(message_network::VersionMessage::new(
+        protocol_version,
         services,
         timestamp as i64,
         addr_recv,
diff --git a/p2p/src/address.rs b/p2p/src/address.rs
new file mode 100644
index 0000000000..1cdfdc77ec
--- /dev/null
+++ b/p2p/src/address.rs
@@ -0,0 +1,978 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network addresses.
+//!
+//! This module defines the structures and functions needed to encode
+//! network addresses in Bitcoin messages.
+
+use alloc::vec;
+use alloc::vec::Vec;
+use core::{fmt, iter};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
+use io::{BufRead, Read, Write};
+
+use crate::ServiceFlags;
+
+/// A message which can be sent on the Bitcoin network
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Address {
+    /// Services provided by the peer whose address this is
+    pub services: ServiceFlags,
+    /// Network byte-order ipv6 address, or ipv4-mapped ipv6 address
+    pub address: [u16; 8],
+    /// Network port
+    pub port: u16,
+}
+
+const ONION: [u16; 3] = [0xFD87, 0xD87E, 0xEB43];
+
+impl Address {
+    /// Constructs a new address message for a socket
+    pub fn new(socket: &SocketAddr, services: ServiceFlags) -> Self {
+        let (address, port) = match *socket {
+            SocketAddr::V4(addr) => (addr.ip().to_ipv6_mapped().segments(), addr.port()),
+            SocketAddr::V6(addr) => (addr.ip().segments(), addr.port()),
+        };
+        Self { services, address, port }
+    }
+
+    /// Builds a useless address that cannot be connected to. One may find this desirable if it is
+    /// known the data will be ignored by the recipient.
+    pub const fn useless() -> Self {
+        Self { services: ServiceFlags::NONE, address: [0; 8], port: 0 }
+    }
+
+    /// Extracts socket address from an [Address] message.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the message contains a Tor V2 onion address.
+    pub fn socket_addr(&self) -> Result<SocketAddr, UnroutableAddressError> {
+        let addr = &self.address;
+        if addr[0..3] == ONION {
+            return Err(UnroutableAddressError::TorV2);
+        }
+        let ipv6 =
+            Ipv6Addr::new(addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
+        if let Some(ipv4) = ipv6.to_ipv4() {
+            Ok(SocketAddr::V4(SocketAddrV4::new(ipv4, self.port)))
+        } else {
+            Ok(SocketAddr::V6(SocketAddrV6::new(ipv6, self.port, 0, 0)))
+        }
+    }
+}
+
+impl Encodable for Address {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = self.services.consensus_encode(w)?;
+
+        for word in &self.address {
+            w.write_all(&word.to_be_bytes())?;
+            len += 2;
+        }
+
+        w.write_all(&self.port.to_be_bytes())?;
+        len += 2;
+
+        Ok(len)
+    }
+}
+
+impl Decodable for Address {
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self {
+            services: Decodable::consensus_decode(r)?,
+            address: read_be_address(r)?,
+            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
+        })
+    }
+}
+
+/// Reads a big-endian address from reader.
+fn read_be_address<R: Read + ?Sized>(r: &mut R) -> Result<[u16; 8], encode::Error> {
+    let mut address = [0u16; 8];
+    let mut buf = [0u8; 2];
+
+    for word in &mut address {
+        Read::read_exact(r, &mut buf)?;
+        *word = u16::from_be_bytes(buf);
+    }
+    Ok(address)
+}
+
+impl fmt::Debug for Address {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let ipv6 = Ipv6Addr::from(self.address);
+
+        match ipv6.to_ipv4() {
+            Some(addr) => write!(
+                f,
+                "Address {{services: {}, address: {}, port: {}}}",
+                self.services, addr, self.port
+            ),
+            None => write!(
+                f,
+                "Address {{services: {}, address: {}, port: {}}}",
+                self.services, ipv6, self.port
+            ),
+        }
+    }
+}
+
+impl ToSocketAddrs for Address {
+    type Iter = iter::Once<SocketAddr>;
+    fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
+        self.socket_addr()
+            .map(iter::once)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))
+    }
+}
+
+/// Supported networks for use in BIP-0155 addrv2 message
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub enum AddrV2 {
+    /// IPV4
+    Ipv4(Ipv4Addr),
+    /// IPV6
+    Ipv6(Ipv6Addr),
+    /// TORV3
+    TorV3([u8; 32]),
+    /// I2P
+    I2p([u8; 32]),
+    /// CJDNS
+    Cjdns(Ipv6Addr),
+    /// Unknown
+    Unknown(u8, Vec<u8>),
+}
+
+impl TryFrom<AddrV2> for IpAddr {
+    type Error = UnroutableAddressError;
+
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
+        match addr {
+            AddrV2::Ipv4(ip) => Ok(Self::V4(ip)),
+            AddrV2::Ipv6(ip) => Ok(Self::V6(ip)),
+            AddrV2::Cjdns(_) => Err(UnroutableAddressError::Cjdns),
+            AddrV2::TorV3(_) => Err(UnroutableAddressError::TorV3),
+            AddrV2::I2p(_) => Err(UnroutableAddressError::I2p),
+            AddrV2::Unknown(_, _) => Err(UnroutableAddressError::Unknown),
+        }
+    }
+}
+
+impl TryFrom<AddrV2> for Ipv4Addr {
+    type Error = AddrV2ToIpv4AddrError;
+
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
+        match addr {
+            AddrV2::Ipv4(ip) => Ok(ip),
+            AddrV2::Ipv6(_) => Err(AddrV2ToIpv4AddrError::Ipv6),
+            AddrV2::Cjdns(_) => Err(AddrV2ToIpv4AddrError::Cjdns),
+            AddrV2::TorV3(_) => Err(AddrV2ToIpv4AddrError::TorV3),
+            AddrV2::I2p(_) => Err(AddrV2ToIpv4AddrError::I2p),
+            AddrV2::Unknown(_, _) => Err(AddrV2ToIpv4AddrError::Unknown),
+        }
+    }
+}
+
+impl TryFrom<AddrV2> for Ipv6Addr {
+    type Error = AddrV2ToIpv6AddrError;
+
+    fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
+        match addr {
+            AddrV2::Ipv6(ip) => Ok(ip),
+            AddrV2::Cjdns(_) => Err(AddrV2ToIpv6AddrError::Cjdns),
+            AddrV2::Ipv4(_) => Err(AddrV2ToIpv6AddrError::Ipv4),
+            AddrV2::TorV3(_) => Err(AddrV2ToIpv6AddrError::TorV3),
+            AddrV2::I2p(_) => Err(AddrV2ToIpv6AddrError::I2p),
+            AddrV2::Unknown(_, _) => Err(AddrV2ToIpv6AddrError::Unknown),
+        }
+    }
+}
+
+impl From<IpAddr> for AddrV2 {
+    fn from(addr: IpAddr) -> Self {
+        match addr {
+            IpAddr::V4(ip) => Self::Ipv4(ip),
+            IpAddr::V6(ip) => Self::Ipv6(ip),
+        }
+    }
+}
+
+impl From<Ipv4Addr> for AddrV2 {
+    fn from(addr: Ipv4Addr) -> Self { Self::Ipv4(addr) }
+}
+
+impl From<Ipv6Addr> for AddrV2 {
+    fn from(addr: Ipv6Addr) -> Self { Self::Ipv6(addr) }
+}
+
+impl Encodable for AddrV2 {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        fn encode_addr<W: Write + ?Sized>(
+            w: &mut W,
+            network: u8,
+            bytes: &[u8],
+        ) -> Result<usize, io::Error> {
+            Ok(network.consensus_encode(w)?
+                + crate::consensus::consensus_encode_with_size(bytes, w)?)
+        }
+        Ok(match *self {
+            Self::Ipv4(ref addr) => encode_addr(w, 1, &addr.octets())?,
+            Self::Ipv6(ref addr) => encode_addr(w, 2, &addr.octets())?,
+            Self::TorV3(ref bytes) => encode_addr(w, 4, bytes)?,
+            Self::I2p(ref bytes) => encode_addr(w, 5, bytes)?,
+            Self::Cjdns(ref addr) => encode_addr(w, 6, &addr.octets())?,
+            Self::Unknown(network, ref bytes) => encode_addr(w, network, bytes)?,
+        })
+    }
+}
+
+impl Decodable for AddrV2 {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let network_id = u8::consensus_decode(r)?;
+        let len = r.read_compact_size()?;
+        if len > 512 {
+            return Err(crate::consensus::parse_failed_error("IP must be <= 512 bytes"));
+        }
+        Ok(match network_id {
+            1 => {
+                if len != 4 {
+                    return Err(crate::consensus::parse_failed_error("invalid IPv4 address"));
+                }
+                let addr: [u8; 4] = Decodable::consensus_decode(r)?;
+                Self::Ipv4(Ipv4Addr::new(addr[0], addr[1], addr[2], addr[3]))
+            }
+            2 => {
+                if len != 16 {
+                    return Err(crate::consensus::parse_failed_error("invalid IPv6 address"));
+                }
+                let addr: [u16; 8] = read_be_address(r)?;
+                if addr[0..3] == ONION {
+                    return Err(crate::consensus::parse_failed_error(
+                        "OnionCat address sent with IPv6 network id",
+                    ));
+                }
+                if addr[0..6] == [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF] {
+                    return Err(crate::consensus::parse_failed_error(
+                        "IPV4 wrapped address sent with IPv6 network id",
+                    ));
+                }
+                Self::Ipv6(Ipv6Addr::new(
+                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
+                ))
+            }
+
+            4 => {
+                if len != 32 {
+                    return Err(crate::consensus::parse_failed_error("invalid TorV3 address"));
+                }
+                let pubkey = Decodable::consensus_decode(r)?;
+                Self::TorV3(pubkey)
+            }
+            5 => {
+                if len != 32 {
+                    return Err(crate::consensus::parse_failed_error("invalid I2P address"));
+                }
+                let hash = Decodable::consensus_decode(r)?;
+                Self::I2p(hash)
+            }
+            6 => {
+                if len != 16 {
+                    return Err(crate::consensus::parse_failed_error("invalid CJDNS address"));
+                }
+                let addr: [u16; 8] = read_be_address(r)?;
+                // check the first byte for the CJDNS marker
+                if addr[0] >> 8 != 0xFC {
+                    return Err(crate::consensus::parse_failed_error("invalid CJDNS address"));
+                }
+                Self::Cjdns(Ipv6Addr::new(
+                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
+                ))
+            }
+            _ => {
+                // len already checked above to be <= 512
+                let mut addr = vec![0u8; len as usize];
+                r.read_slice(&mut addr)?;
+                Self::Unknown(network_id, addr)
+            }
+        })
+    }
+}
+
+/// Address received from BIP-0155 addrv2 message
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct AddrV2Message {
+    /// Time that this node was last seen as connected to the network
+    pub time: u32,
+    /// Service bits
+    pub services: ServiceFlags,
+    /// Network ID + Network Address
+    pub addr: AddrV2,
+    /// Network port, 0 if not applicable
+    pub port: u16,
+}
+
+impl AddrV2Message {
+    /// Extracts socket address from an [`AddrV2Message`] message.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the address type cannot be converted to a socket address
+    /// (e.g. Tor, I2P, CJDNS addresses).
+    pub fn socket_addr(&self) -> Result<SocketAddr, UnroutableAddressError> {
+        match self.addr {
+            AddrV2::Ipv4(addr) => Ok(SocketAddr::V4(SocketAddrV4::new(addr, self.port))),
+            AddrV2::Ipv6(addr) => Ok(SocketAddr::V6(SocketAddrV6::new(addr, self.port, 0, 0))),
+            AddrV2::TorV3(_) => Err(UnroutableAddressError::TorV3),
+            AddrV2::I2p(_) => Err(UnroutableAddressError::I2p),
+            AddrV2::Cjdns(_) => Err(UnroutableAddressError::Cjdns),
+            AddrV2::Unknown(_, _) => Err(UnroutableAddressError::Unknown),
+        }
+    }
+}
+
+impl Encodable for AddrV2Message {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.time.consensus_encode(w)?;
+        len += w.emit_compact_size(self.services.to_u64())?;
+        len += self.addr.consensus_encode(w)?;
+
+        w.write_all(&self.port.to_be_bytes())?;
+        len += 2; // port u16 is two bytes.
+
+        Ok(len)
+    }
+}
+
+impl Decodable for AddrV2Message {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self {
+            time: Decodable::consensus_decode(r)?,
+            services: ServiceFlags::from(r.read_compact_size()?),
+            addr: Decodable::consensus_decode(r)?,
+            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
+        })
+    }
+}
+
+impl ToSocketAddrs for AddrV2Message {
+    type Iter = iter::Once<SocketAddr>;
+    fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
+        self.socket_addr()
+            .map(iter::once)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))
+    }
+}
+
+/// Error returned when an address cannot be converted to an IP-based address.
+///
+/// Addresses like Tor, I2P, and CJDNS use different routing mechanisms
+/// and cannot be represented as standard IP addresses or socket addresses.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum UnroutableAddressError {
+    /// Tor V2 onion address.
+    TorV2,
+    /// Tor V3 onion address.
+    TorV3,
+    /// I2P address.
+    I2p,
+    /// CJDNS address.
+    Cjdns,
+    /// Unknown address type.
+    Unknown,
+}
+
+impl fmt::Display for UnroutableAddressError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::TorV2 => write!(f, "Tor v2 addresses cannot be converted to IP addresses"),
+            Self::TorV3 => write!(f, "Tor v3 addresses cannot be converted to IP addresses"),
+            Self::I2p => write!(f, "I2P addresses cannot be converted to IP addresses"),
+            Self::Cjdns => write!(f, "CJDNS addresses cannot be converted to IP addresses"),
+            Self::Unknown => write!(f, "unknown address type cannot be converted to IP addresses"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnroutableAddressError {}
+
+/// Error types for [`AddrV2`] to [`IpAddr`] conversion.
+#[derive(Debug, PartialEq, Eq)]
+pub enum AddrV2ToIpAddrError {
+    /// A [`AddrV2::TorV3`] address cannot be converted to a [`IpAddr`].
+    TorV3,
+    /// A [`AddrV2::I2p`] address cannot be converted to a [`IpAddr`].
+    I2p,
+    /// A [`AddrV2::Cjdns`] address cannot be converted to a [`IpAddr`],
+    Cjdns,
+    /// A [`AddrV2::Unknown`] address cannot be converted to a [`IpAddr`].
+    Unknown,
+}
+
+impl fmt::Display for AddrV2ToIpAddrError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::TorV3 => write!(f, "TorV3 addresses cannot be converted to IpAddr"),
+            Self::I2p => write!(f, "I2P addresses cannot be converted to IpAddr"),
+            Self::Cjdns => write!(f, "Cjdns addresses cannot be converted to IpAddr"),
+            Self::Unknown => write!(f, "Unknown address type cannot be converted to IpAddr"),
+        }
+    }
+}
+
+impl std::error::Error for AddrV2ToIpAddrError {}
+
+/// Error types for [`AddrV2`] to [`Ipv4Addr`] conversion.
+#[derive(Debug, PartialEq, Eq)]
+pub enum AddrV2ToIpv4AddrError {
+    /// A [`AddrV2::Ipv6`] address cannot be converted to a [`Ipv4Addr`].
+    Ipv6,
+    /// A [`AddrV2::TorV3`] address cannot be converted to a [`Ipv4Addr`].
+    TorV3,
+    /// A [`AddrV2::I2p`] address cannot be converted to a [`Ipv4Addr`].
+    I2p,
+    /// A [`AddrV2::Cjdns`] address cannot be converted to a [`Ipv4Addr`],
+    Cjdns,
+    /// A [`AddrV2::Unknown`] address cannot be converted to a [`Ipv4Addr`].
+    Unknown,
+}
+
+impl fmt::Display for AddrV2ToIpv4AddrError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ipv6 => write!(f, "Ipv6 addresses cannot be converted to Ipv4Addr"),
+            Self::TorV3 => write!(f, "TorV3 addresses cannot be converted to Ipv4Addr"),
+            Self::I2p => write!(f, "I2P addresses cannot be converted to Ipv4Addr"),
+            Self::Cjdns => write!(f, "Cjdns addresses cannot be converted to Ipv4Addr"),
+            Self::Unknown => write!(f, "Unknown address type cannot be converted to Ipv4Addr"),
+        }
+    }
+}
+
+impl std::error::Error for AddrV2ToIpv4AddrError {}
+
+/// Error types for [`AddrV2`] to [`Ipv6Addr`] conversion.
+#[derive(Debug, PartialEq, Eq)]
+pub enum AddrV2ToIpv6AddrError {
+    /// A [`AddrV2::Ipv4`] address cannot be converted to a [`Ipv6Addr`].
+    Ipv4,
+    /// A [`AddrV2::TorV3`] address cannot be converted to a [`Ipv6Addr`].
+    TorV3,
+    /// A [`AddrV2::I2p`] address cannot be converted to a [`Ipv6Addr`].
+    I2p,
+    /// A [`AddrV2::Cjdns`] address cannot be converted to a [`Ipv6Addr`],
+    Cjdns,
+    /// A [`AddrV2::Unknown`] address cannot be converted to a [`Ipv6Addr`].
+    Unknown,
+}
+
+impl fmt::Display for AddrV2ToIpv6AddrError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ipv4 => write!(f, "Ipv4 addresses cannot be converted to Ipv6Addr"),
+            Self::TorV3 => write!(f, "TorV3 addresses cannot be converted to Ipv6Addr"),
+            Self::I2p => write!(f, "I2P addresses cannot be converted to Ipv6Addr"),
+            Self::Cjdns => write!(f, "Cjdns addresses cannot be converted to Ipv6Addr"),
+            Self::Unknown => write!(f, "Unknown address type cannot be converted to Ipv6Addr"),
+        }
+    }
+}
+
+impl std::error::Error for AddrV2ToIpv6AddrError {}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Address {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let socket_addr = match bool::arbitrary(u)? {
+            true => SocketAddr::new(
+                IpAddr::V4(Ipv4Addr::new(
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                )),
+                u.arbitrary()?,
+            ),
+            false => SocketAddr::new(
+                IpAddr::V6(Ipv6Addr::new(
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                    u.arbitrary()?,
+                )),
+                u.arbitrary()?,
+            ),
+        };
+
+        Ok(Self::new(&socket_addr, u.arbitrary()?))
+    }
+}
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for AddrV2 {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=5)? {
+            0 => Ok(Self::Ipv4(Ipv4Addr::new(
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+            ))),
+            1 => Ok(Self::Ipv6(Ipv6Addr::new(
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+            ))),
+            2 => Ok(Self::TorV3(u.arbitrary()?)),
+            3 => Ok(Self::I2p(u.arbitrary()?)),
+            4 => Ok(Self::Cjdns(Ipv6Addr::new(
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+                u.arbitrary()?,
+            ))),
+            _ => Ok(Self::Unknown(u.arbitrary()?, Vec::<u8>::arbitrary(u)?)),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for AddrV2Message {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            time: u.arbitrary()?,
+            services: u.arbitrary()?,
+            addr: u.arbitrary()?,
+            port: u.arbitrary()?,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use alloc::{format, vec};
+    use std::net::IpAddr;
+
+    use bitcoin::consensus::encode::{deserialize, serialize};
+    use hex::FromHex;
+    use hex_lit::hex;
+
+    use super::*;
+    use crate::message::AddrV2Payload;
+
+    #[test]
+    fn serialize_address() {
+        assert_eq!(
+            serialize(&Address {
+                services: ServiceFlags::NETWORK,
+                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            [
+                1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+                0x20, 0x8d
+            ]
+        );
+    }
+
+    #[test]
+    fn debug_format() {
+        let mut flags = ServiceFlags::NETWORK;
+        assert_eq!(
+            format!("The address is: {:?}", Address {
+                services: flags.add(ServiceFlags::WITNESS),
+                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            "The address is: Address {services: ServiceFlags(NETWORK|WITNESS), address: 10.0.0.1, port: 8333}"
+        );
+
+        assert_eq!(
+            format!("The address is: {:?}", Address {
+                services: ServiceFlags::NETWORK_LIMITED,
+                address: [0xFD87, 0xD87E, 0xEB43, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            "The address is: Address {services: ServiceFlags(NETWORK_LIMITED), address: fd87:d87e:eb43::ffff:a00:1, port: 8333}"
+        );
+    }
+
+    #[test]
+    fn deserialize_address() {
+        let mut addr: Result<Address, _> = deserialize(&[
+            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+            0x20, 0x8d,
+        ]);
+        assert!(addr.is_ok());
+        let full = addr.unwrap();
+        assert!(matches!(full.socket_addr().unwrap(), SocketAddr::V4(_)));
+        assert_eq!(full.services, ServiceFlags::NETWORK);
+        assert_eq!(full.address, [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001]);
+        assert_eq!(full.port, 8333);
+
+        addr = deserialize(&[
+            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+        ]);
+        assert!(addr.is_err());
+    }
+
+    #[test]
+    fn socket_addr() {
+        let s4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(111, 222, 123, 4)), 5555);
+        let a4 = Address::new(&s4, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
+        assert_eq!(a4.socket_addr().unwrap(), s4);
+        let s6 = SocketAddr::new(
+            IpAddr::V6(Ipv6Addr::new(
+                0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888,
+            )),
+            9999,
+        );
+        let a6 = Address::new(&s6, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
+        assert_eq!(a6.socket_addr().unwrap(), s6);
+    }
+
+    #[test]
+    fn onion() {
+        let onionaddr = SocketAddr::new(
+            IpAddr::V6("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca".parse::<Ipv6Addr>().unwrap()),
+            1111,
+        );
+        let addr = Address::new(&onionaddr, ServiceFlags::NONE);
+        assert!(addr.socket_addr().is_err());
+    }
+
+    #[test]
+    fn serialize_addrv2() {
+        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L348
+
+        let ip = AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4));
+        assert_eq!(serialize(&ip), hex!("010401020304"));
+
+        let ip =
+            AddrV2::Ipv6("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b".parse::<Ipv6Addr>().unwrap());
+        assert_eq!(serialize(&ip), hex!("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"));
+
+        let ip = AddrV2::TorV3(
+            FromHex::from_hex("53cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
+                .unwrap(),
+        );
+        assert_eq!(
+            serialize(&ip),
+            hex!("042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
+        );
+
+        let ip = AddrV2::I2p(
+            FromHex::from_hex("a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
+                .unwrap(),
+        );
+        assert_eq!(
+            serialize(&ip),
+            hex!("0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
+        );
+
+        let ip = AddrV2::Cjdns("fc01:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap());
+        assert_eq!(serialize(&ip), hex!("0610fc010001000200030004000500060007"));
+
+        let ip = AddrV2::Unknown(170, hex!("01020304").to_vec());
+        assert_eq!(serialize(&ip), hex!("aa0401020304"));
+    }
+
+    #[test]
+    fn deserialize_addrv2() {
+        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L386
+
+        // Valid IPv4.
+        let ip: AddrV2 = deserialize(&hex!("010401020304")).unwrap();
+        assert_eq!(ip, AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4)));
+
+        // Invalid IPv4, valid length but address itself is shorter.
+        deserialize::<AddrV2>(&hex!("01040102")).unwrap_err();
+
+        // Invalid IPv4, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("010501020304")).is_err());
+
+        // Invalid IPv4, with extreme length.
+        assert!(deserialize::<AddrV2>(&hex!("01fd010201020304")).is_err());
+
+        // Valid IPv6.
+        let ip: AddrV2 = deserialize(&hex!("02100102030405060708090a0b0c0d0e0f10")).unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::Ipv6("102:304:506:708:90a:b0c:d0e:f10".parse::<Ipv6Addr>().unwrap())
+        );
+
+        // Invalid IPv6, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("020400")).is_err());
+
+        // Invalid IPv6, contains embedded IPv4.
+        assert!(deserialize::<AddrV2>(&hex!("021000000000000000000000ffff01020304")).is_err());
+
+        // Invalid IPv6, contains embedded TORv2.
+        assert!(deserialize::<AddrV2>(&hex!("0210fd87d87eeb430102030405060708090a")).is_err());
+
+        // Valid TORv3.
+        let ip: AddrV2 = deserialize(&hex!(
+            "042079bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
+        ))
+        .unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::TorV3(
+                FromHex::from_hex(
+                    "79bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
+                )
+                .unwrap()
+            )
+        );
+
+        // Invalid TORv3, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("040000")).is_err());
+
+        // Valid I2P.
+        let ip: AddrV2 = deserialize(&hex!(
+            "0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
+        ))
+        .unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::I2p(
+                FromHex::from_hex(
+                    "a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
+                )
+                .unwrap()
+            )
+        );
+
+        // Invalid I2P, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("050300")).is_err());
+
+        // Valid CJDNS.
+        let ip: AddrV2 = deserialize(&hex!("0610fc000001000200030004000500060007")).unwrap();
+        assert_eq!(ip, AddrV2::Cjdns("fc00:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap()));
+
+        // Invalid CJDNS, incorrect marker
+        assert!(deserialize::<AddrV2>(&hex!("0610fd000001000200030004000500060007")).is_err());
+
+        // Invalid CJDNS, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("060100")).is_err());
+
+        // Unknown, with extreme length.
+        assert!(deserialize::<AddrV2>(&hex!("aafe0000000201020304050607")).is_err());
+
+        // Unknown, with reasonable length.
+        let ip: AddrV2 = deserialize(&hex!("aa0401020304")).unwrap();
+        assert_eq!(ip, AddrV2::Unknown(170, hex!("01020304").to_vec()));
+
+        // Unknown, with zero length.
+        let ip: AddrV2 = deserialize(&hex!("aa00")).unwrap();
+        assert_eq!(ip, AddrV2::Unknown(170, vec![]));
+    }
+
+    #[test]
+    fn addrv2message() {
+        let raw = hex!("0261bc6649019902abab208d79627683fd4804010409090909208d");
+        let addresses: AddrV2Payload = deserialize(&raw).unwrap();
+
+        assert_eq!(
+            addresses.0,
+            vec![
+                AddrV2Message {
+                    services: ServiceFlags::NETWORK,
+                    time: 0x4966_bc61,
+                    port: 8333,
+                    addr: AddrV2::Unknown(153, hex!("abab").to_vec())
+                },
+                AddrV2Message {
+                    services: ServiceFlags::NETWORK_LIMITED
+                        | ServiceFlags::WITNESS
+                        | ServiceFlags::COMPACT_FILTERS,
+                    time: 0x8376_6279,
+                    port: 8333,
+                    addr: AddrV2::Ipv4(Ipv4Addr::new(9, 9, 9, 9))
+                },
+            ]
+        );
+
+        assert_eq!(serialize(&addresses), raw);
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_ipv4() {
+        let addr = AddrV2::Ipv4(Ipv4Addr::new(192, 168, 1, 1));
+        let ip_addr = IpAddr::try_from(addr).unwrap();
+
+        assert_eq!(ip_addr, IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1)));
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_ipv6() {
+        let addr = AddrV2::Ipv6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+        let ip_addr = IpAddr::try_from(addr).unwrap();
+
+        assert_eq!(ip_addr, IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)));
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_cjdns() {
+        let addr = AddrV2::Cjdns(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1));
+        let result = IpAddr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::Cjdns);
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_torv3() {
+        let addr = AddrV2::TorV3([0; 32]);
+        let result = IpAddr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::TorV3);
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_i2p() {
+        let addr = AddrV2::I2p([0; 32]);
+        let result = IpAddr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::I2p);
+    }
+
+    #[test]
+    fn addrv2_to_ipaddr_unknown() {
+        let addr = AddrV2::Unknown(42, vec![1, 2, 3, 4]);
+        let result = IpAddr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::Unknown);
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_ipv4() {
+        let addr = AddrV2::Ipv4(Ipv4Addr::new(192, 168, 1, 1));
+        let ip_addr = Ipv4Addr::try_from(addr).unwrap();
+
+        assert_eq!(ip_addr, Ipv4Addr::new(192, 168, 1, 1));
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_ipv6() {
+        let addr = AddrV2::Ipv6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+        let result = Ipv4Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv4AddrError::Ipv6);
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_cjdns() {
+        let addr = AddrV2::Cjdns(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1));
+        let result = Ipv4Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv4AddrError::Cjdns);
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_torv3() {
+        let addr = AddrV2::TorV3([0; 32]);
+        let result = Ipv4Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv4AddrError::TorV3);
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_i2p() {
+        let addr = AddrV2::I2p([0; 32]);
+        let result = Ipv4Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv4AddrError::I2p);
+    }
+
+    #[test]
+    fn addrv2_to_ipv4addr_unknown() {
+        let addr = AddrV2::Unknown(42, vec![1, 2, 3, 4]);
+        let result = Ipv4Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv4AddrError::Unknown);
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_ipv4() {
+        let addr = AddrV2::Ipv4(Ipv4Addr::new(192, 168, 1, 1));
+        let result = Ipv6Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv6AddrError::Ipv4);
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_ipv6() {
+        let addr = AddrV2::Ipv6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+        let ip_addr = Ipv6Addr::try_from(addr).unwrap();
+
+        assert_eq!(ip_addr, Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_cjdns() {
+        let addr = AddrV2::Cjdns(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 1));
+        let result = Ipv6Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv6AddrError::Cjdns);
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_torv3() {
+        let addr = AddrV2::TorV3([0; 32]);
+        let result = Ipv6Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv6AddrError::TorV3);
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_i2p() {
+        let addr = AddrV2::I2p([0; 32]);
+        let result = Ipv6Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv6AddrError::I2p);
+    }
+
+    #[test]
+    fn addrv2_to_ipv6addr_unknown() {
+        let addr = AddrV2::Unknown(42, vec![1, 2, 3, 4]);
+        let result = Ipv6Addr::try_from(addr);
+
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), AddrV2ToIpv6AddrError::Unknown);
+    }
+}
diff --git a/bitcoin/src/bip152.rs b/p2p/src/bip152.rs
similarity index 78%
rename from bitcoin/src/bip152.rs
rename to p2p/src/bip152.rs
index 5aed10c940..448d601459 100644
--- a/bitcoin/src/bip152.rs
+++ b/p2p/src/bip152.rs
@@ -1,28 +1,26 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! BIP152 Compact Blocks.
+//! BIP-0152 Compact Blocks.
 //!
 //! Implementation of compact blocks data structure and algorithms.
 
+use alloc::vec::Vec;
 use core::convert::Infallible;
 use core::{convert, fmt, mem};
 #[cfg(feature = "std")]
 use std::error;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
+use bitcoin::transaction::TxIdentifier;
+use bitcoin::{block, Block, BlockChecked, BlockHash, Transaction};
 use hashes::{sha256, siphash24};
 use internals::array::ArrayExt as _;
 use internals::ToU64 as _;
 use io::{BufRead, Write};
 
-use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
-use crate::internal_macros::{
-    impl_array_newtype, impl_array_newtype_stringify, impl_consensus_encoding,
-};
-use crate::prelude::Vec;
-use crate::transaction::TxIdentifier;
-use crate::{block, consensus, Block, BlockChecked, BlockHash, Transaction};
-
-/// A BIP-152 error
+/// A BIP-0152 error
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Error {
@@ -39,8 +37,8 @@ impl From<Infallible> for Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::UnknownVersion => write!(f, "an unknown version number was used"),
-            Error::InvalidPrefill => write!(f, "the prefill slice provided was invalid"),
+            Self::UnknownVersion => write!(f, "an unknown version number was used"),
+            Self::InvalidPrefill => write!(f, "the prefill slice provided was invalid"),
         }
     }
 }
@@ -48,10 +46,8 @@ impl fmt::Display for Error {
 #[cfg(feature = "std")]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use self::Error::*;
-
-        match *self {
-            UnknownVersion | InvalidPrefill => None,
+        match self {
+            Self::UnknownVersion | Self::InvalidPrefill => None,
         }
     }
 }
@@ -91,21 +87,24 @@ impl Decodable for PrefilledTransaction {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         let idx = r.read_compact_size()?;
         let idx = u16::try_from(idx).map_err(|_| {
-            consensus::parse_failed_error("BIP152 prefilled tx index out of bounds")
+            crate::consensus::parse_failed_error("BIP-0152 prefilled tx index out of bounds")
         })?;
         let tx = Transaction::consensus_decode(r)?;
-        Ok(PrefilledTransaction { idx, tx })
+        Ok(Self { idx, tx })
     }
 }
 
 /// Short transaction IDs are used to represent a transaction without sending a full 256-bit hash.
 #[derive(PartialEq, Eq, Clone, Copy, Hash, Default, PartialOrd, Ord)]
 pub struct ShortId([u8; 6]);
-impl_array_newtype!(ShortId, u8, 6);
-impl_array_newtype_stringify!(ShortId, 6);
+internals::impl_array_newtype!(ShortId, u8, 6);
 
 impl ShortId {
-    /// Calculates the SipHash24 keys used to calculate short IDs.
+    /// Calculates the `SipHash24` keys used to calculate short IDs.
+    ///
+    /// # Panics
+    ///
+    /// Panics if consensus encoding fails (should never happen for in-memory operations).
     pub fn calculate_siphash_keys(header: &block::Header, nonce: u64) -> (u64, u64) {
         // 1. single-SHA256 hashing the block header with the nonce appended (in little-endian)
         let h = {
@@ -123,19 +122,43 @@ impl ShortId {
         )
     }
 
-    /// Calculates the short ID with the given (w)txid and using the provided SipHash keys.
-    pub fn with_siphash_keys<T: TxIdentifier>(txid: &T, siphash_keys: (u64, u64)) -> ShortId {
+    /// Calculates the short ID with the given (w)txid and using the provided `SipHash` keys.
+    pub fn with_siphash_keys<T: TxIdentifier>(txid: &T, siphash_keys: (u64, u64)) -> Self {
         // 2. Running SipHash-2-4 with the input being the transaction ID and the keys (k0/k1)
         // set to the first two little-endian 64-bit integers from the above hash, respectively.
         let hash = siphash24::Hash::hash_with_keys(siphash_keys.0, siphash_keys.1, txid.as_ref());
 
         // 3. Dropping the 2 most significant bytes from the SipHash output to make it 6 bytes.
-        let mut id = ShortId([0; 6]);
+        let mut id = Self([0; 6]);
         id.0.copy_from_slice(&hash.as_byte_array()[0..6]);
         id
     }
 }
 
+impl core::fmt::LowerHex for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        hex::display::fmt_hex_exact!(f, 6, &self.0, hex::Case::Lower)
+    }
+}
+
+impl core::fmt::UpperHex for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        hex::display::fmt_hex_exact!(f, 6, &self.0, hex::Case::Upper)
+    }
+}
+
+impl core::fmt::Display for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl core::fmt::Debug for ShortId {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        core::fmt::LowerHex::fmt(self, f)
+    }
+}
+
 impl Encodable for ShortId {
     #[inline]
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
@@ -145,8 +168,8 @@ impl Encodable for ShortId {
 
 impl Decodable for ShortId {
     #[inline]
-    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<ShortId, encode::Error> {
-        Ok(ShortId(Decodable::consensus_decode(r)?))
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self(Decodable::consensus_decode(r)?))
     }
 }
 
@@ -162,7 +185,7 @@ pub struct HeaderAndShortIds {
     ///  A nonce for use in short transaction ID calculations.
     pub nonce: u64,
     ///  The short transaction IDs calculated from the transactions
-    ///  which were not provided explicitly in prefilled_txs.
+    ///  which were not provided explicitly in `prefilled_txs`.
     pub short_ids: Vec<ShortId>,
     ///  Used to provide the coinbase transaction and a select few
     ///  which we expect a peer may be missing.
@@ -171,7 +194,7 @@ pub struct HeaderAndShortIds {
 
 impl Decodable for HeaderAndShortIds {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        let header_short_ids = HeaderAndShortIds {
+        let header_short_ids = Self {
             header: Decodable::consensus_decode(r)?,
             nonce: Decodable::consensus_decode(r)?,
             short_ids: Decodable::consensus_decode(r)?,
@@ -179,7 +202,7 @@ impl Decodable for HeaderAndShortIds {
         };
         match header_short_ids.short_ids.len().checked_add(header_short_ids.prefilled_txs.len()) {
             Some(x) if x <= u16::MAX.into() => Ok(header_short_ids),
-            _ => Err(consensus::parse_failed_error("indexes overflowed 16 bits")),
+            _ => Err(crate::consensus::parse_failed_error("indexes overflowed 16 bits")),
         }
     }
 }
@@ -206,12 +229,16 @@ impl HeaderAndShortIds {
     /// coinbase tx is always prefilled.
     ///
     /// > Nodes SHOULD NOT use the same nonce across multiple different blocks.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the version is not 1 or 2, or if the prefill indexes are invalid.
     pub fn from_block(
         block: &Block<BlockChecked>,
         nonce: u64,
         version: u32,
         mut prefill: &[usize],
-    ) -> Result<HeaderAndShortIds, Error> {
+    ) -> Result<Self, Error> {
         if version != 1 && version != 2 {
             return Err(Error::UnknownVersion);
         }
@@ -240,13 +267,13 @@ impl HeaderAndShortIds {
                         1 => {
                             // strip witness for version 1
                             let mut no_witness = tx.clone();
-                            no_witness.input.iter_mut().for_each(|i| i.witness.clear());
+                            no_witness.inputs.iter_mut().for_each(|i| i.witness.clear());
                             no_witness
                         }
                         // > Transactions inside cmpctblock messages (both those used as direct
                         // > announcement and those in response to getdata) and in blocktxn should
                         // > include witness data, using the same format as responses to getdata
-                        // > MSG_WITNESS_TX, specified in BIP144.
+                        // > MSG_WITNESS_TX, specified in BIP-0144.
                         2 => tx.clone(),
                         _ => unreachable!(),
                     },
@@ -266,7 +293,7 @@ impl HeaderAndShortIds {
             return Err(Error::InvalidPrefill);
         }
 
-        Ok(HeaderAndShortIds {
+        Ok(Self {
             header: *block.header(),
             nonce,
             // Provide coinbase prefilled.
@@ -289,13 +316,9 @@ pub struct BlockTransactionsRequest {
 }
 
 impl Encodable for BlockTransactionsRequest {
-    /// # Panics
-    ///
-    /// Panics if the index overflows [`u64::MAX`]. This happens when [`BlockTransactionsRequest::indexes`]
-    /// contains an entry with the value [`u64::MAX`] as `u64` overflows during differential encoding.
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         let mut len = self.block_hash.consensus_encode(w)?;
-        // Manually encode indexes because they are differentially encoded VarInts.
+        // Manually encode indexes because they are differentially encoded as CompactSize.
         len += w.emit_compact_size(self.indexes.len())?;
         let mut last_idx = 0;
         for idx in &self.indexes {
@@ -308,10 +331,10 @@ impl Encodable for BlockTransactionsRequest {
 
 impl Decodable for BlockTransactionsRequest {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(BlockTransactionsRequest {
+        Ok(Self {
             block_hash: BlockHash::consensus_decode(r)?,
             indexes: {
-                // Manually decode indexes because they are differentially encoded VarInts.
+                // Manually decode indexes because they are differentially encoded as CompactSize.
                 let nb_indexes = r.read_compact_size()? as usize;
 
                 // Since the number of indices ultimately represent transactions,
@@ -319,7 +342,7 @@ impl Decodable for BlockTransactionsRequest {
                 // transactions that would be allowed in a vector.
                 let byte_size = nb_indexes
                     .checked_mul(mem::size_of::<Transaction>())
-                    .ok_or(consensus::parse_failed_error("invalid length"))?;
+                    .ok_or(crate::consensus::parse_failed_error("invalid length"))?;
                 if byte_size > encode::MAX_VEC_SIZE {
                     return Err(encode::ParseError::OversizedVectorAllocation {
                         requested: byte_size,
@@ -334,12 +357,18 @@ impl Decodable for BlockTransactionsRequest {
                     let differential = r.read_compact_size()?;
                     last_index = match last_index.checked_add(differential) {
                         Some(i) => i,
-                        None => return Err(consensus::parse_failed_error("block index overflow")),
+                        None =>
+                            return Err(crate::consensus::parse_failed_error(
+                                "block index overflow",
+                            )),
                     };
                     indexes.push(last_index);
                     last_index = match last_index.checked_add(1) {
                         Some(i) => i,
-                        None => return Err(consensus::parse_failed_error("block index overflow")),
+                        None =>
+                            return Err(crate::consensus::parse_failed_error(
+                                "block index overflow",
+                            )),
                     };
                 }
                 indexes
@@ -379,16 +408,20 @@ pub struct BlockTransactions {
     ///  The transactions provided.
     pub transactions: Vec<Transaction>,
 }
-impl_consensus_encoding!(BlockTransactions, block_hash, transactions);
+crate::consensus::impl_consensus_encoding!(BlockTransactions, block_hash, transactions);
 
 impl BlockTransactions {
     /// Constructs a new [`BlockTransactions`] from a [`BlockTransactionsRequest`] and
     /// the corresponding full [`Block`] by providing all requested transactions.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any requested transaction index is out of range for the block.
     pub fn from_request(
         request: &BlockTransactionsRequest,
         block: &Block<BlockChecked>,
-    ) -> Result<BlockTransactions, TxIndexOutOfRangeError> {
-        Ok(BlockTransactions {
+    ) -> Result<Self, TxIndexOutOfRangeError> {
+        Ok(Self {
             block_hash: request.block_hash,
             transactions: {
                 let mut txs = Vec::with_capacity(request.indexes.len());
@@ -404,32 +437,71 @@ impl BlockTransactions {
     }
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for ShortId {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for PrefilledTransaction {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { idx: u.arbitrary()?, tx: u.arbitrary()? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for HeaderAndShortIds {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            header: u.arbitrary()?,
+            nonce: u.arbitrary()?,
+            short_ids: Vec::<ShortId>::arbitrary(u)?,
+            prefilled_txs: Vec::<PrefilledTransaction>::arbitrary(u)?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BlockTransactions {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { block_hash: u.arbitrary()?, transactions: Vec::<Transaction>::arbitrary(u)? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BlockTransactionsRequest {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { block_hash: u.arbitrary()?, indexes: Vec::<u64>::arbitrary(u)? })
+    }
+}
+
 #[cfg(test)]
 mod test {
+    use alloc::vec;
+
+    use bitcoin::consensus::encode::{deserialize, serialize};
+    use bitcoin::locktime::absolute;
+    use bitcoin::merkle_tree::TxMerkleNode;
+    use bitcoin::{
+        transaction, Amount, BlockChecked, BlockTime, CompactTarget, OutPoint, ScriptPubKeyBuf,
+        ScriptSigBuf, Sequence, TxIn, TxOut, Txid, Witness,
+    };
     use hex::FromHex;
 
     use super::*;
-    use crate::consensus::encode::{deserialize, serialize};
-    use crate::locktime::absolute;
-    use crate::merkle_tree::TxMerkleNode;
-    use crate::transaction::OutPointExt;
-    use crate::{
-        transaction, Amount, BlockChecked, BlockTime, CompactTarget, OutPoint, ScriptBuf, Sequence,
-        TxIn, TxOut, Txid, Witness,
-    };
 
     fn dummy_tx(nonce: &[u8]) -> Transaction {
         let dummy_txid = Txid::from_byte_array(hashes::sha256::Hash::hash(nonce).to_byte_array());
         Transaction {
             version: transaction::Version::ONE,
             lock_time: absolute::LockTime::from_consensus(2),
-            input: vec![TxIn {
-                previous_output: OutPoint::new(dummy_txid, 0),
-                script_sig: ScriptBuf::new(),
+            inputs: vec![TxIn {
+                previous_output: OutPoint { txid: dummy_txid, vout: 0 },
+                script_sig: ScriptSigBuf::new(),
                 sequence: Sequence(1),
                 witness: Witness::new(),
             }],
-            output: vec![TxOut { value: Amount::ONE_SAT, script_pubkey: ScriptBuf::new() }],
+            outputs: vec![TxOut { amount: Amount::ONE_SAT, script_pubkey: ScriptPubKeyBuf::new() }],
         }
     }
 
@@ -474,7 +546,7 @@ mod test {
 
         let block: Block = deserialize(&raw_block).unwrap();
         let block = block.assume_checked(None);
-        let nonce = 18053200567810711460;
+        let nonce = 18_053_200_567_810_711_460;
         let compact = HeaderAndShortIds::from_block(&block, nonce, 2, &[]).unwrap();
         let compact_expected = deserialize(&raw_compact).unwrap();
 
@@ -484,23 +556,23 @@ mod test {
     #[test]
     fn getblocktx_differential_encoding_de_and_serialization() {
         let testcases = vec![
-            // differentially encoded VarInts, indices
+            // differentially encoded CompactSizes, indices
             (vec![4, 0, 5, 1, 10], vec![0, 6, 8, 19]),
             (vec![1, 0], vec![0]),
             (vec![5, 0, 0, 0, 0, 0], vec![0, 1, 2, 3, 4]),
             (vec![3, 1, 1, 1], vec![1, 3, 5]),
-            (vec![3, 0, 0, 253, 0, 1], vec![0, 1, 258]), // .., 253, 0, 1] == VarInt(256)
+            (vec![3, 0, 0, 253, 0, 1], vec![0, 1, 258]), // .., 253, 0, 1] == CompactSize(256)
         ];
         let deser_errorcases = vec![
-            vec![2, 255, 254, 255, 255, 255, 255, 255, 255, 255, 0], // .., 255, 254, .., 255] == VarInt(u64::MAX-1)
-            vec![1, 255, 255, 255, 255, 255, 255, 255, 255, 255], // .., 255, 255, .., 255] == VarInt(u64::MAX)
+            vec![2, 255, 254, 255, 255, 255, 255, 255, 255, 255, 0], // .., 255, 254, .., 255] == CompactSize(u64::MAX-1)
+            vec![1, 255, 255, 255, 255, 255, 255, 255, 255, 255], // .., 255, 255, .., 255] == CompactSize(u64::MAX)
         ];
         for testcase in testcases {
             {
                 // test deserialization
-                let mut raw: Vec<u8> = [0u8; 32].to_vec();
+                let mut raw: Vec<u8> = vec![0u8; 32];
                 raw.extend(testcase.0.clone());
-                let btr: BlockTransactionsRequest = deserialize(&raw.to_vec()).unwrap();
+                let btr: BlockTransactionsRequest = deserialize(&raw.clone()).unwrap();
                 assert_eq!(testcase.1, btr.indexes);
             }
             {
@@ -519,14 +591,14 @@ mod test {
                 // test that we return Err() if deserialization fails (and don't panic)
                 let mut raw: Vec<u8> = [0u8; 32].to_vec();
                 raw.extend(errorcase);
-                assert!(deserialize::<BlockTransactionsRequest>(&raw.to_vec()).is_err());
+                assert!(deserialize::<BlockTransactionsRequest>(&raw.clone()).is_err());
             }
         }
     }
 
     #[test]
     #[cfg(debug_assertions)]
-    #[should_panic] // 'attempt to add with overflow' in consensus_encode()
+    #[should_panic(expected = "attempt to add with overflow")]
     fn getblocktx_panic_when_encoding_u64_max() {
         serialize(&BlockTransactionsRequest {
             block_hash: BlockHash::from_byte_array([0; 32]),
diff --git a/p2p/src/consensus.rs b/p2p/src/consensus.rs
new file mode 100644
index 0000000000..5bc377d727
--- /dev/null
+++ b/p2p/src/consensus.rs
@@ -0,0 +1,101 @@
+#[cfg(feature = "std")]
+use bitcoin::consensus::encode::WriteExt;
+#[cfg(feature = "std")]
+use io::Write;
+
+#[cfg(feature = "std")]
+pub(crate) fn consensus_encode_with_size<W: Write + ?Sized>(
+    data: &[u8],
+    w: &mut W,
+) -> Result<usize, io::Error> {
+    Ok(w.emit_compact_size(data.len())? + w.emit_slice(data)?)
+}
+
+pub(crate) fn parse_failed_error(msg: &'static str) -> bitcoin::consensus::encode::Error {
+    bitcoin::consensus::encode::Error::Parse(bitcoin::consensus::encode::ParseError::ParseFailed(
+        msg,
+    ))
+}
+
+macro_rules! impl_consensus_encoding {
+    ($thing:ident, $($field:ident),+) => (
+        impl bitcoin::consensus::Encodable for $thing {
+            #[inline]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> core::result::Result<usize, io::Error> {
+                let mut len = 0;
+                $(len += self.$field.consensus_encode(w)?;)+
+                Ok(len)
+            }
+        }
+
+        impl bitcoin::consensus::Decodable for $thing {
+
+            #[inline]
+            fn consensus_decode_from_finite_reader<R: io::BufRead + ?Sized>(
+                r: &mut R,
+            ) -> core::result::Result<$thing, bitcoin::consensus::encode::Error> {
+                Ok($thing {
+                    $($field: bitcoin::consensus::Decodable::consensus_decode_from_finite_reader(r)?),+
+                })
+            }
+
+            #[inline]
+            fn consensus_decode<R: io::BufRead + ?Sized>(
+                r: &mut R,
+            ) -> core::result::Result<$thing, bitcoin::consensus::encode::Error> {
+                let mut r = io::Read::take(r, internals::ToU64::to_u64(bitcoin::consensus::encode::MAX_VEC_SIZE));
+                Ok($thing {
+                    $($field: bitcoin::consensus::Decodable::consensus_decode(&mut r)?),+
+                })
+            }
+        }
+    );
+}
+pub(crate) use impl_consensus_encoding;
+
+#[cfg(feature = "std")]
+macro_rules! impl_vec_wrapper {
+    ($wrapper: ident, $type: ty) => {
+        impl bitcoin::consensus::encode::Encodable for $wrapper {
+            #[inline]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> core::result::Result<usize, io::Error> {
+                let mut len = 0;
+                len += w.emit_compact_size(self.0.len())?;
+                for c in self.0.iter() {
+                    len += c.consensus_encode(w)?;
+                }
+                Ok(len)
+            }
+        }
+
+        impl bitcoin::consensus::encode::Decodable for $wrapper {
+            #[inline]
+            fn consensus_decode_from_finite_reader<R: io::BufRead + ?Sized>(
+                r: &mut R,
+            ) -> core::result::Result<$wrapper, bitcoin::consensus::encode::Error> {
+                let len = r.read_compact_size()?;
+                // Limit the initial vec allocation to at most 8,000 bytes, which is
+                // sufficient for most use cases. We don't allocate more space upfront
+                // than this, since `len` is an untrusted allocation capacity. If the
+                // vector does overflow the initial capacity `push` will just reallocate.
+                // Note: OOM protection relies on reader eventually running out of
+                // data to feed us.
+                let max_init_capacity = 8000 / core::mem::size_of::<$type>();
+                let mut ret = Vec::with_capacity(core::cmp::min(len as usize, max_init_capacity));
+                for _ in 0..len {
+                    ret.push(Decodable::consensus_decode_from_finite_reader(r)?);
+                }
+                Ok($wrapper(ret))
+            }
+        }
+    };
+}
+
+#[cfg(feature = "std")]
+pub(crate) use impl_vec_wrapper;
diff --git a/bitcoin/src/p2p/mod.rs b/p2p/src/lib.rs
similarity index 55%
rename from bitcoin/src/p2p/mod.rs
rename to p2p/src/lib.rs
index cb9c1f5a86..2d51fb45cc 100644
--- a/bitcoin/src/p2p/mod.rs
+++ b/p2p/src/lib.rs
@@ -1,42 +1,56 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Bitcoin p2p network types.
-//!
-//! This module defines support for (de)serialization and network transport
-//! of Bitcoin data and Bitcoin p2p network messages.
+//! Rust Bitcoin Peer to Peer Message Types
+
+#![no_std]
+// Coding conventions.
+#![warn(missing_docs)]
+#![warn(deprecated_in_future)]
+#![doc(test(attr(warn(unused))))]
+
+mod consensus;
+mod network_ext;
 
 #[cfg(feature = "std")]
 pub mod address;
+pub mod bip152;
 #[cfg(feature = "std")]
 pub mod message;
-#[cfg(feature = "std")]
 pub mod message_blockdata;
-#[cfg(feature = "std")]
 pub mod message_bloom;
-#[cfg(feature = "std")]
 pub mod message_compact_blocks;
-#[cfg(feature = "std")]
 pub mod message_filter;
 #[cfg(feature = "std")]
 pub mod message_network;
 
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use core::borrow::{Borrow, BorrowMut};
 use core::str::FromStr;
 use core::{fmt, ops};
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::encode::{self, Decodable, Encodable};
+use bitcoin::network::{Network, Params, TestnetVersion};
 use hex::FromHex;
-use internals::{impl_to_hex_from_lower_hex, write_err};
+use internals::impl_to_hex_from_lower_hex;
 use io::{BufRead, Write};
 
-use crate::consensus::encode::{self, Decodable, Encodable};
-use crate::network::{Network, Params, TestnetVersion};
-use crate::prelude::{Borrow, BorrowMut, String, ToOwned};
-
 #[rustfmt::skip]
 #[doc(inline)]
+pub use self::network_ext::NetworkExt;
+
 #[cfg(feature = "std")]
-pub use self::address::Address;
+#[rustfmt::skip]
+#[doc(inline)]
+pub use self::{address::Address, message::CheckedData};
 
-/// Version of the protocol as appearing in network message headers.
+/// Version of the protocol as appearing in network version handshakes and some message headers.
 ///
 /// This constant is used to signal to other peers which features you support. Increasing it implies
 /// that your software also supports every feature prior to this version. Doing so without support
@@ -48,12 +62,53 @@ pub use self::address::Address;
 /// 70014 - Support compact block messages `sendcmpct`, `cmpctblock`, `getblocktxn` and `blocktxn`
 /// 70013 - Support `feefilter` message
 /// 70012 - Support `sendheaders` message and announce new blocks via headers rather than inv
-/// 70011 - Support NODE_BLOOM service flag and don't support bloom filter messages if it is not set
+/// 70011 - Support `NODE_BLOOM` service flag and don't support bloom filter messages if it is not set
 /// 70002 - Support `reject` message
-/// 70001 - Support bloom filter messages `filterload`, `filterclear` `filteradd`, `merkleblock` and FILTERED_BLOCK inventory type
+/// 70001 - Support bloom filter messages `filterload`, `filterclear` `filteradd`, `merkleblock` and `FILTERED_BLOCK` inventory type
 /// 60002 - Support `mempool` message
 /// 60001 - Support `pong` message and nonce in `ping` message
-pub const PROTOCOL_VERSION: u32 = 70001;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ProtocolVersion(u32);
+
+impl ProtocolVersion {
+    /// Support receiving `wtxidrelay` message between `version` and `verack` message
+    pub const WTXID_RELAY_VERSION: Self = Self(70016);
+    /// Support receiving invalid compact blocks from a peer without banning them
+    pub const INVALID_CB_NO_BAN_VERSION: Self = Self(70015);
+    /// Support compact block messages `sendcmpct`, `cmpctblock`, `getblocktxn` and `blocktxn`
+    pub const SHORT_IDS_BLOCKS_VERSION: Self = Self(70014);
+    /// Support `feefilter` message
+    pub const FEEFILTER_VERSION: Self = Self(70013);
+    /// Support `sendheaders` message and announce new blocks via headers rather than inv
+    pub const SENDHEADERS_VERSION: Self = Self(70012);
+    /// Support `pong` message and nonce in `ping` message
+    pub const BIP0031_VERSION: Self = Self(60001);
+    /// All connections will be terminated below this version.
+    pub const MIN_PEER_PROTO_VERSION: Self = Self(31800);
+}
+
+impl ProtocolVersion {
+    /// Constructs a protocol version that is not well-known.
+    pub fn from_nonstandard(version: u32) -> Self { Self(version) }
+}
+
+impl From<ProtocolVersion> for u32 {
+    fn from(version: ProtocolVersion) -> Self { version.0 }
+}
+
+impl Encodable for ProtocolVersion {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for ProtocolVersion {
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Self(Decodable::consensus_decode(r)?))
+    }
+}
 
 /// Flags to indicate which network services a node supports.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -61,60 +116,62 @@ pub struct ServiceFlags(u64);
 
 impl ServiceFlags {
     /// NONE means no services supported.
-    pub const NONE: ServiceFlags = ServiceFlags(0);
+    pub const NONE: Self = Self(0);
 
     /// NETWORK means that the node is capable of serving the complete block chain. It is currently
     /// set by all Bitcoin Core non pruned nodes, and is unset by SPV clients or other light
     /// clients.
-    pub const NETWORK: ServiceFlags = ServiceFlags(1 << 0);
+    pub const NETWORK: Self = Self(1 << 0);
 
     /// GETUTXO means the node is capable of responding to the getutxo protocol request. Bitcoin
     /// Core does not support this but a patch set called Bitcoin XT does.
-    /// See BIP 64 for details on how this is implemented.
-    pub const GETUTXO: ServiceFlags = ServiceFlags(1 << 1);
+    /// See BIP-0064 for details on how this is implemented.
+    pub const GETUTXO: Self = Self(1 << 1);
 
     /// BLOOM means the node is capable and willing to handle bloom-filtered connections. Bitcoin
     /// Core nodes used to support this by default, without advertising this bit, but no longer do
-    /// as of protocol version 70011 (= NO_BLOOM_VERSION)
-    pub const BLOOM: ServiceFlags = ServiceFlags(1 << 2);
+    /// as of protocol version 70011 (= `NO_BLOOM_VERSION`)
+    pub const BLOOM: Self = Self(1 << 2);
 
     /// WITNESS indicates that a node can be asked for blocks and transactions including witness
     /// data.
-    pub const WITNESS: ServiceFlags = ServiceFlags(1 << 3);
+    pub const WITNESS: Self = Self(1 << 3);
 
-    /// COMPACT_FILTERS means the node will service basic block filter requests.
-    /// See BIP157 and BIP158 for details on how this is implemented.
-    pub const COMPACT_FILTERS: ServiceFlags = ServiceFlags(1 << 6);
+    /// `COMPACT_FILTERS` means the node will service basic block filter requests.
+    /// See BIP-0157 and BIP-0158 for details on how this is implemented.
+    pub const COMPACT_FILTERS: Self = Self(1 << 6);
 
-    /// NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only serving the last
+    /// `NETWORK_LIMITED` means the same as `NODE_NETWORK` with the limitation of only serving the last
     /// 288 (2 day) blocks.
-    /// See BIP159 for details on how this is implemented.
-    pub const NETWORK_LIMITED: ServiceFlags = ServiceFlags(1 << 10);
+    /// See BIP-0159 for details on how this is implemented.
+    pub const NETWORK_LIMITED: Self = Self(1 << 10);
 
-    /// P2P_V2 indicates that the node supports the P2P v2 encrypted transport protocol.
-    /// See BIP324 for details on how this is implemented.
-    pub const P2P_V2: ServiceFlags = ServiceFlags(1 << 11);
+    /// `P2P_V2` indicates that the node supports the P2P v2 encrypted transport protocol.
+    /// See BIP-0324 for details on how this is implemented.
+    pub const P2P_V2: Self = Self(1 << 11);
 
     // NOTE: When adding new flags, remember to update the Display impl accordingly.
 
-    /// Add [ServiceFlags] together.
+    /// Add [`ServiceFlags`] together.
     ///
     /// Returns itself.
-    pub fn add(&mut self, other: ServiceFlags) -> ServiceFlags {
+    #[must_use]
+    pub fn add(&mut self, other: Self) -> Self {
         self.0 |= other.0;
         *self
     }
 
-    /// Remove [ServiceFlags] from this.
+    /// Removes [`ServiceFlags`] from this.
     ///
     /// Returns itself.
-    pub fn remove(&mut self, other: ServiceFlags) -> ServiceFlags {
+    #[must_use]
+    pub fn remove(&mut self, other: Self) -> Self {
         self.0 &= !other.0;
         *self
     }
 
-    /// Check whether [ServiceFlags] are included in this one.
-    pub fn has(self, flags: ServiceFlags) -> bool { (self.0 | flags.0) == self.0 }
+    /// Checks whether [`ServiceFlags`] are included in this one.
+    pub fn has(self, flags: Self) -> bool { (self.0 | flags.0) == self.0 }
 
     /// Gets the integer representation of this [`ServiceFlags`].
     pub fn to_u64(self) -> u64 { self.0 }
@@ -133,7 +190,7 @@ impl fmt::UpperHex for ServiceFlags {
 impl fmt::Display for ServiceFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut flags = *self;
-        if flags == ServiceFlags::NONE {
+        if flags == Self::NONE {
             return write!(f, "ServiceFlags(NONE)");
         }
         let mut first = true;
@@ -145,7 +202,7 @@ impl fmt::Display for ServiceFlags {
                     }
                     first = false;
                     write!(f, stringify!($f))?;
-                    flags.remove(ServiceFlags::$f);
+                    let _ = flags.remove(ServiceFlags::$f);
                 }
             };
         }
@@ -158,7 +215,7 @@ impl fmt::Display for ServiceFlags {
         write_flag!(NETWORK_LIMITED);
         write_flag!(P2P_V2);
         // If there are unknown flags left, we append them in hex.
-        if flags != ServiceFlags::NONE {
+        if flags != Self::NONE {
             if !first {
                 write!(f, "|")?;
             }
@@ -169,7 +226,7 @@ impl fmt::Display for ServiceFlags {
 }
 
 impl From<u64> for ServiceFlags {
-    fn from(f: u64) -> Self { ServiceFlags(f) }
+    fn from(f: u64) -> Self { Self(f) }
 }
 
 impl From<ServiceFlags> for u64 {
@@ -183,7 +240,7 @@ impl ops::BitOr for ServiceFlags {
 }
 
 impl ops::BitOrAssign for ServiceFlags {
-    fn bitor_assign(&mut self, rhs: Self) { self.add(rhs); }
+    fn bitor_assign(&mut self, rhs: Self) { let _ = self.add(rhs); }
 }
 
 impl ops::BitXor for ServiceFlags {
@@ -193,7 +250,7 @@ impl ops::BitXor for ServiceFlags {
 }
 
 impl ops::BitXorAssign for ServiceFlags {
-    fn bitxor_assign(&mut self, rhs: Self) { self.remove(rhs); }
+    fn bitxor_assign(&mut self, rhs: Self) { let _ = self.remove(rhs); }
 }
 
 impl Encodable for ServiceFlags {
@@ -206,7 +263,7 @@ impl Encodable for ServiceFlags {
 impl Decodable for ServiceFlags {
     #[inline]
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Ok(ServiceFlags(Decodable::consensus_decode(r)?))
+        Ok(Self(Decodable::consensus_decode(r)?))
     }
 }
 /// Network magic bytes to identify the cryptocurrency network the message was intended for.
@@ -217,9 +274,6 @@ impl Magic {
     /// Bitcoin mainnet network magic bytes.
     pub const BITCOIN: Self = Self([0xF9, 0xBE, 0xB4, 0xD9]);
     /// Bitcoin testnet3 network magic bytes.
-    #[deprecated(since = "0.33.0", note = "use `TESTNET3` instead")]
-    pub const TESTNET: Self = Self([0x0B, 0x11, 0x09, 0x07]);
-    /// Bitcoin testnet3 network magic bytes.
     pub const TESTNET3: Self = Self([0x0B, 0x11, 0x09, 0x07]);
     /// Bitcoin testnet4 network magic bytes.
     pub const TESTNET4: Self = Self([0x1c, 0x16, 0x3f, 0x28]);
@@ -228,61 +282,57 @@ impl Magic {
     /// Bitcoin regtest network magic bytes.
     pub const REGTEST: Self = Self([0xFA, 0xBF, 0xB5, 0xDA]);
 
-    /// Construct a new network magic from bytes.
-    pub const fn from_bytes(bytes: [u8; 4]) -> Magic { Magic(bytes) }
+    /// Constructs a new network magic from bytes.
+    pub const fn from_bytes(bytes: [u8; 4]) -> Self { Self(bytes) }
 
-    /// Get network magic bytes.
+    /// Gets network magic bytes.
     pub fn to_bytes(self) -> [u8; 4] { self.0 }
 
     /// Returns the magic bytes for the network defined by `params`.
-    pub fn from_params(params: impl AsRef<Params>) -> Self { params.as_ref().network.into() }
+    pub fn from_params(params: impl AsRef<Params>) -> Option<Self> {
+        params.as_ref().network.try_into().ok()
+    }
 }
 
 impl FromStr for Magic {
     type Err = ParseMagicError;
 
-    fn from_str(s: &str) -> Result<Magic, Self::Err> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         match <[u8; 4]>::from_hex(s) {
-            Ok(magic) => Ok(Magic::from_bytes(magic)),
+            Ok(magic) => Ok(Self::from_bytes(magic)),
             Err(e) => Err(ParseMagicError { error: e, magic: s.to_owned() }),
         }
     }
 }
 
-macro_rules! generate_network_magic_conversion {
-    ($(Network::$network:ident$((TestnetVersion::$testnet_version:ident))? => Magic::$magic:ident,)*) => {
-        impl From<Network> for Magic {
-            fn from(network: Network) -> Magic {
-                match network {
-                    $(
-                        Network::$network$((TestnetVersion::$testnet_version))? => Magic::$magic,
-                    )*
-                }
-            }
+impl TryFrom<Network> for Magic {
+    type Error = UnknownNetworkError;
+
+    fn try_from(network: Network) -> Result<Self, Self::Error> {
+        match network {
+            Network::Bitcoin => Ok(Self::BITCOIN),
+            Network::Testnet(TestnetVersion::V3) => Ok(Self::TESTNET3),
+            Network::Testnet(TestnetVersion::V4) => Ok(Self::TESTNET4),
+            Network::Signet => Ok(Self::SIGNET),
+            Network::Regtest => Ok(Self::REGTEST),
+            Network::Testnet(_) => Err(UnknownNetworkError(network)),
         }
+    }
+}
 
-        impl TryFrom<Magic> for Network {
-            type Error = UnknownMagicError;
+impl TryFrom<Magic> for Network {
+    type Error = UnknownMagicError;
 
-            fn try_from(magic: Magic) -> Result<Self, Self::Error> {
-                match magic {
-                    $(
-                        Magic::$magic => Ok(Network::$network$((TestnetVersion::$testnet_version))?),
-                    )*
-                    _ => Err(UnknownMagicError(magic)),
-                }
-            }
+    fn try_from(magic: Magic) -> Result<Self, Self::Error> {
+        match magic {
+            Magic::BITCOIN => Ok(Self::Bitcoin),
+            Magic::TESTNET3 => Ok(Self::Testnet(TestnetVersion::V3)),
+            Magic::TESTNET4 => Ok(Self::Testnet(TestnetVersion::V4)),
+            Magic::SIGNET => Ok(Self::Signet),
+            Magic::REGTEST => Ok(Self::Regtest),
+            _ => Err(UnknownMagicError(magic)),
         }
-    };
-}
-// Generate conversion functions for all known networks.
-// `Network -> Magic` and `Magic -> Network`
-generate_network_magic_conversion! {
-    Network::Bitcoin => Magic::BITCOIN,
-    Network::Testnet(TestnetVersion::V3) => Magic::TESTNET3,
-    Network::Testnet(TestnetVersion::V4) => Magic::TESTNET4,
-    Network::Signet => Magic::SIGNET,
-    Network::Regtest => Magic::REGTEST,
+    }
 }
 
 impl fmt::Display for Magic {
@@ -319,7 +369,7 @@ impl Encodable for Magic {
 
 impl Decodable for Magic {
     fn consensus_decode<R: BufRead + ?Sized>(reader: &mut R) -> Result<Self, encode::Error> {
-        Ok(Magic(Decodable::consensus_decode(reader)?))
+        Ok(Self(Decodable::consensus_decode(reader)?))
     }
 }
 
@@ -367,7 +417,7 @@ pub struct ParseMagicError {
 
 impl fmt::Display for ParseMagicError {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write_err!(f, "failed to parse {} as network magic", self.magic; self.error)
+        write!(f, "failed to parse {} as network magic", self.magic)
     }
 }
 
@@ -392,10 +442,85 @@ impl std::error::Error for UnknownMagicError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
 
+/// Error in creating a Magic from a Network.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct UnknownNetworkError(Network);
+
+impl fmt::Display for UnknownNetworkError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(f, "unknown network {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnknownNetworkError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for ProtocolVersion {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for ServiceFlags {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Magic {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
+}
+
 #[cfg(test)]
 mod tests {
+    use alloc::string::ToString;
+
+    use bitcoin::consensus::encode::{deserialize, serialize};
+
     use super::*;
 
+    #[test]
+    fn serialize_deserialize() {
+        assert_eq!(serialize(&Magic::BITCOIN), &[0xf9, 0xbe, 0xb4, 0xd9]);
+        let magic: Magic = Network::Bitcoin.try_into().unwrap();
+        assert_eq!(serialize(&magic), &[0xf9, 0xbe, 0xb4, 0xd9]);
+        assert_eq!(serialize(&Magic::TESTNET3), &[0x0b, 0x11, 0x09, 0x07]);
+        let magic: Magic = Network::Testnet(TestnetVersion::V3).try_into().unwrap();
+        assert_eq!(serialize(&magic), &[0x0b, 0x11, 0x09, 0x07]);
+        assert_eq!(serialize(&Magic::TESTNET4), &[0x1c, 0x16, 0x3f, 0x28]);
+        let magic: Magic = Network::Testnet(TestnetVersion::V4).try_into().unwrap();
+        assert_eq!(serialize(&magic), &[0x1c, 0x16, 0x3f, 0x28]);
+        assert_eq!(serialize(&Magic::SIGNET), &[0x0a, 0x03, 0xcf, 0x40]);
+        let magic: Magic = Network::Signet.try_into().unwrap();
+        assert_eq!(serialize(&magic), &[0x0a, 0x03, 0xcf, 0x40]);
+        assert_eq!(serialize(&Magic::REGTEST), &[0xfa, 0xbf, 0xb5, 0xda]);
+        let magic: Magic = Network::Regtest.try_into().unwrap();
+        assert_eq!(serialize(&magic), &[0xfa, 0xbf, 0xb5, 0xda]);
+
+        assert_eq!(
+            deserialize::<Magic>(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(),
+            Network::Bitcoin.try_into().ok()
+        );
+        assert_eq!(
+            deserialize::<Magic>(&[0x0b, 0x11, 0x09, 0x07]).ok(),
+            Network::Testnet(TestnetVersion::V3).try_into().ok()
+        );
+        assert_eq!(
+            deserialize::<Magic>(&[0x1c, 0x16, 0x3f, 0x28]).ok(),
+            Network::Testnet(TestnetVersion::V4).try_into().ok()
+        );
+        assert_eq!(
+            deserialize::<Magic>(&[0x0a, 0x03, 0xcf, 0x40]).ok(),
+            Network::Signet.try_into().ok()
+        );
+        assert_eq!(
+            deserialize::<Magic>(&[0xfa, 0xbf, 0xb5, 0xda]).ok(),
+            Network::Regtest.try_into().ok()
+        );
+    }
+
     #[test]
     fn service_flags_test() {
         let all = [
@@ -409,7 +534,7 @@ mod tests {
         ];
 
         let mut flags = ServiceFlags::NONE;
-        for f in all.iter() {
+        for f in &all {
             assert!(!flags.has(*f));
         }
 
@@ -417,7 +542,7 @@ mod tests {
         assert_eq!(flags, ServiceFlags::WITNESS);
 
         let mut flags2 = flags | ServiceFlags::GETUTXO;
-        for f in all.iter() {
+        for f in &all {
             assert_eq!(flags2.has(*f), *f == ServiceFlags::WITNESS || *f == ServiceFlags::GETUTXO);
         }
 
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
new file mode 100644
index 0000000000..555c5a3850
--- /dev/null
+++ b/p2p/src/message.rs
@@ -0,0 +1,2125 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network messages.
+//!
+//! This module defines the `NetworkMessage` and `RawNetworkMessage` types that
+//! are used for (de)serializing Bitcoin objects for transmission on the network.
+
+use alloc::borrow::{Cow, ToOwned};
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::{cmp, fmt};
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
+use bitcoin::merkle_tree::MerkleBlock;
+use encoding;
+use hashes::sha256d;
+use internals::ToU64 as _;
+use io::{self, BufRead, Read, Write};
+use primitives::{block, transaction};
+use units::FeeRate;
+
+use crate::address::{AddrV2Message, Address};
+use crate::consensus::{impl_consensus_encoding, impl_vec_wrapper};
+use crate::{
+    message_blockdata, message_bloom, message_compact_blocks, message_filter, message_network,
+    Magic,
+};
+
+/// The maximum number of [`super::message_blockdata::Inventory`] items in an `inv` message.
+///
+/// This limit is not currently enforced by this implementation.
+pub const MAX_INV_SIZE: usize = 50_000;
+
+/// Maximum size, in bytes, of an encoded message
+/// This by necessity should be larger than `MAX_VEC_SIZE`
+pub const MAX_MSG_SIZE: usize = 5_000_000;
+
+/// Serializer for command string
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CommandString(Cow<'static, str>);
+
+impl CommandString {
+    /// Converts `&'static str` to `CommandString`
+    ///
+    /// This is more efficient for string literals than non-static conversions because it avoids
+    /// allocation.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if, and only if, the string is
+    /// larger than 12 characters in length.
+    pub fn try_from_static(s: &'static str) -> Result<Self, CommandStringError> {
+        Self::try_from_static_cow(s.into())
+    }
+
+    fn try_from_static_cow(cow: Cow<'static, str>) -> Result<Self, CommandStringError> {
+        if cow.len() > 12 {
+            Err(CommandStringError { cow })
+        } else {
+            Ok(Self(cow))
+        }
+    }
+}
+
+impl TryFrom<String> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(value.into())
+    }
+}
+
+impl TryFrom<Box<str>> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: Box<str>) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(String::from(value).into())
+    }
+}
+
+impl<'a> TryFrom<&'a str> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(value.to_owned().into())
+    }
+}
+
+impl core::str::FromStr for CommandString {
+    type Err = CommandStringError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::try_from_static_cow(s.to_owned().into())
+    }
+}
+
+impl fmt::Display for CommandString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(self.0.as_ref()) }
+}
+
+impl AsRef<str> for CommandString {
+    fn as_ref(&self) -> &str { self.0.as_ref() }
+}
+
+impl Encodable for CommandString {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut rawbytes = [0u8; 12];
+        let strbytes = self.0.as_bytes();
+        debug_assert!(strbytes.len() <= 12);
+        rawbytes[..strbytes.len()].copy_from_slice(strbytes);
+        rawbytes.consensus_encode(w)
+    }
+}
+
+impl Decodable for CommandString {
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let rawbytes: [u8; 12] = Decodable::consensus_decode(r)?;
+
+        // Find the last non-null byte and trim null padding from the end
+        let trimmed = &rawbytes[..rawbytes.iter().rposition(|&b| b != 0).map_or(0, |i| i + 1)];
+
+        if !trimmed.is_ascii() {
+            return Err(crate::consensus::parse_failed_error("Command string must be ASCII"));
+        }
+
+        Ok(Self(Cow::Owned(unsafe { String::from_utf8_unchecked(trimmed.to_vec()) })))
+    }
+}
+
+impl encoding::Encodable for CommandString {
+    type Encoder<'e> = encoding::ArrayEncoder<12>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let mut rawbytes = [0u8; 12];
+        let strbytes = self.0.as_bytes();
+        debug_assert!(strbytes.len() <= 12);
+        rawbytes[..strbytes.len()].copy_from_slice(strbytes);
+        encoding::ArrayEncoder::without_length_prefix(rawbytes)
+    }
+}
+
+impl encoding::Decodable for CommandString {
+    type Decoder = CommandStringDecoder;
+
+    fn decoder() -> Self::Decoder { CommandStringDecoder { inner: encoding::ArrayDecoder::new() } }
+}
+
+/// Decoder for [`CommandString`].
+pub struct CommandStringDecoder {
+    inner: encoding::ArrayDecoder<12>,
+}
+
+impl encoding::Decoder for CommandStringDecoder {
+    type Output = CommandString;
+    type Error = CommandStringDecodeError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(CommandStringDecodeError::UnexpectedEof)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let rawbytes = self.inner.end().map_err(CommandStringDecodeError::UnexpectedEof)?;
+        // Trim null padding from the end.
+        let trimmed =
+            rawbytes.iter().rposition(|&b| b != 0).map_or(&rawbytes[..0], |i| &rawbytes[..=i]);
+
+        if !trimmed.is_ascii() {
+            return Err(CommandStringDecodeError::NotAscii);
+        }
+
+        Ok(CommandString(Cow::Owned(unsafe { String::from_utf8_unchecked(trimmed.to_vec()) })))
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// Error decoding a [`CommandString`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum CommandStringDecodeError {
+    /// Unexpected end of data.
+    UnexpectedEof(encoding::UnexpectedEofError),
+    /// Command string contains non-ASCII characters.
+    NotAscii,
+}
+
+impl fmt::Display for CommandStringDecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::UnexpectedEof(e) => write!(f, "unexpected end of data: {}", e),
+            Self::NotAscii => write!(f, "command string must be ASCII"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CommandStringDecodeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::UnexpectedEof(e) => Some(e),
+            Self::NotAscii => None,
+        }
+    }
+}
+
+/// Error returned when a command string is invalid.
+///
+/// This is currently returned for command strings longer than 12.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct CommandStringError {
+    cow: Cow<'static, str>,
+}
+
+impl fmt::Display for CommandStringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "the command string '{}' has length {} which is larger than 12",
+            self.cow,
+            self.cow.len()
+        )
+    }
+}
+
+impl std::error::Error for CommandStringError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// A Network message using the v1 p2p protocol.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RawNetworkMessage {
+    magic: Magic,
+    payload: NetworkMessage,
+    payload_len: u32,
+    checksum: [u8; 4],
+}
+
+/// A v1 message header used to describe the incoming payload.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct V1MessageHeader {
+    /// The network magic, a unique 4 byte sequence.
+    pub magic: Magic,
+    /// The "command" used to describe the payload.
+    pub command: CommandString,
+    /// The length of the payload.
+    pub length: u32,
+    /// A checksum to the aforementioned data.
+    pub checksum: [u8; 4],
+}
+
+impl_consensus_encoding!(V1MessageHeader, magic, command, length, checksum);
+
+/// A Network message using the v2 p2p protocol defined in BIP-0324.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct V2NetworkMessage {
+    payload: NetworkMessage,
+}
+
+/// A list of inventory items.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct InventoryPayload(pub Vec<message_blockdata::Inventory>);
+
+/// A list of legacy p2p address messages.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct AddrPayload(pub Vec<(u32, Address)>);
+
+/// A list of v2 address messages.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct AddrV2Payload(pub Vec<AddrV2Message>);
+
+impl_vec_wrapper!(InventoryPayload, message_blockdata::Inventory);
+impl_vec_wrapper!(AddrPayload, (u32, Address));
+impl_vec_wrapper!(AddrV2Payload, AddrV2Message);
+
+/// The `feefilter` message, wrapper around [`FeeRate`] for P2P wire format encoding.
+///
+/// This message is used to inform peers about the minimum fee rate for transactions
+/// that should be relayed which is defined in [BIP-0133].
+///
+/// [BIP-0133]: <https://github.com/bitcoin/bips/blob/master/bip-0133.mediawiki>
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FeeFilter(FeeRate);
+
+impl FeeFilter {
+    /// Constructs a new `FeeFilter` from a [`FeeRate`].
+    pub const fn new(fee_rate: FeeRate) -> Self { Self(fee_rate) }
+
+    /// Returns the inner [`FeeRate`].
+    pub const fn fee_rate(self) -> FeeRate { self.0 }
+}
+
+impl From<FeeRate> for FeeFilter {
+    fn from(fee_rate: FeeRate) -> Self { Self(fee_rate) }
+}
+
+impl From<FeeFilter> for FeeRate {
+    fn from(filter: FeeFilter) -> Self { filter.0 }
+}
+
+impl bitcoin::consensus::encode::Encodable for FeeFilter {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        use encoding::Encoder;
+        let mut encoder = encoding::Encodable::encoder(self);
+        loop {
+            w.write_all(encoder.current_chunk())?;
+            if !encoder.advance() {
+                break;
+            }
+        }
+        Ok(8)
+    }
+}
+
+impl bitcoin::consensus::encode::Decodable for FeeFilter {
+    fn consensus_decode<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, bitcoin::consensus::encode::Error> {
+        use encoding::Decoder;
+
+        let mut decoder = <Self as encoding::Decodable>::decoder();
+        let mut buffer = [0u8; 8];
+
+        r.read_exact(&mut buffer)?;
+
+        let mut slice = &buffer[..];
+        decoder.push_bytes(&mut slice).map_err(|_| {
+            bitcoin::consensus::encode::Error::Io(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "insufficient data for FeeFilter",
+            ))
+        })?;
+
+        decoder.end().map_err(|_| {
+            bitcoin::consensus::encode::Error::Io(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "insufficient data for FeeFilter",
+            ))
+        })
+    }
+}
+
+encoding::encoder_newtype! {
+    /// Encoder for [`FeeFilter`] type.
+    pub struct FeeFilterEncoder(encoding::ArrayEncoder<8>);
+}
+
+impl encoding::Encodable for FeeFilter {
+    type Encoder<'e> = FeeFilterEncoder;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        // Encode as sat/kvB in little-endian (BIP 133 wire format).
+        let kvb = self.0.to_sat_per_kvb_ceil();
+        FeeFilterEncoder(encoding::ArrayEncoder::without_length_prefix(kvb.to_le_bytes()))
+    }
+}
+
+/// Decoder for [`FeeFilter`] type.
+pub struct FeeFilterDecoder(encoding::ArrayDecoder<8>);
+
+impl FeeFilterDecoder {
+    /// Constructs a new [`FeeFilter`] decoder.
+    pub fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for FeeFilterDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for FeeFilterDecoder {
+    type Output = FeeFilter;
+    type Error = encoding::UnexpectedEofError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let array = self.0.end()?;
+        let kvb = u64::from_le_bytes(array);
+
+        // BIP-0133 specifies feefilter as int64_t (signed), but negative values and values
+        // exceeding u32::MAX are invalid for fee rates. We saturate both cases to FeeRate::MAX.
+        let fee_rate = kvb.try_into().ok().map_or(FeeRate::MAX, FeeRate::from_sat_per_kvb);
+
+        Ok(FeeFilter(fee_rate))
+    }
+
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for FeeFilter {
+    type Decoder = FeeFilterDecoder;
+
+    fn decoder() -> Self::Decoder { FeeFilterDecoder::new() }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FeeFilter {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=3)?;
+        match choice {
+            0 => Ok(Self(FeeRate::MIN)),
+            1 => Ok(Self(FeeRate::BROADCAST_MIN)),
+            2 => Ok(Self(FeeRate::DUST)),
+            _ => Ok(Self(FeeRate::from_sat_per_kvb(u.int_in_range(0..=u32::MAX)?))),
+        }
+    }
+}
+
+/// A Network message payload. Proper documentation is available at
+/// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum NetworkMessage {
+    /// `version`
+    Version(message_network::VersionMessage),
+    /// `verack`
+    Verack,
+    /// `addr`
+    Addr(AddrPayload),
+    /// `inv`
+    Inv(InventoryPayload),
+    /// `getdata`
+    GetData(InventoryPayload),
+    /// `notfound`
+    NotFound(InventoryPayload),
+    /// `getblocks`
+    GetBlocks(message_blockdata::GetBlocksMessage),
+    /// `getheaders`
+    GetHeaders(message_blockdata::GetHeadersMessage),
+    /// `mempool`
+    MemPool,
+    /// tx
+    Tx(transaction::Transaction),
+    /// `block`
+    Block(block::Block),
+    /// `headers`
+    Headers(HeadersMessage),
+    /// `sendheaders`
+    SendHeaders,
+    /// `getaddr`
+    GetAddr,
+    /// `ping`
+    Ping(u64),
+    /// `pong`
+    Pong(u64),
+    /// `merkleblock`
+    MerkleBlock(MerkleBlock),
+    /// BIP-0037 `filterload`
+    FilterLoad(message_bloom::FilterLoad),
+    /// BIP-0037 `filteradd`
+    FilterAdd(message_bloom::FilterAdd),
+    /// BIP-0037 `filterclear`
+    FilterClear,
+    /// BIP-0157 getcfilters
+    GetCFilters(message_filter::GetCFilters),
+    /// BIP-0157 cfilter
+    CFilter(message_filter::CFilter),
+    /// BIP-0157 getcfheaders
+    GetCFHeaders(message_filter::GetCFHeaders),
+    /// BIP-0157 cfheaders
+    CFHeaders(message_filter::CFHeaders),
+    /// BIP-0157 getcfcheckpt
+    GetCFCheckpt(message_filter::GetCFCheckpt),
+    /// BIP-0157 cfcheckpt
+    CFCheckpt(message_filter::CFCheckpt),
+    /// BIP-0152 sendcmpct
+    SendCmpct(message_compact_blocks::SendCmpct),
+    /// BIP-0152 cmpctblock
+    CmpctBlock(message_compact_blocks::CmpctBlock),
+    /// BIP-0152 getblocktxn
+    GetBlockTxn(message_compact_blocks::GetBlockTxn),
+    /// BIP-0152 blocktxn
+    BlockTxn(message_compact_blocks::BlockTxn),
+    /// `alert`
+    Alert(message_network::Alert),
+    /// `reject`
+    Reject(message_network::Reject),
+    /// `feefilter`
+    FeeFilter(FeeFilter),
+    /// `wtxidrelay`
+    WtxidRelay,
+    /// `addrv2`
+    AddrV2(AddrV2Payload),
+    /// `sendaddrv2`
+    SendAddrV2,
+
+    /// Any other message.
+    Unknown {
+        /// The command of this message.
+        command: CommandString,
+        /// The payload of this message.
+        payload: Vec<u8>,
+    },
+}
+
+impl NetworkMessage {
+    /// Returns the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [`NetworkMessage::Unknown`],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [`Self::command`] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str {
+        match *self {
+            Self::Version(_) => "version",
+            Self::Verack => "verack",
+            Self::Addr(_) => "addr",
+            Self::Inv(_) => "inv",
+            Self::GetData(_) => "getdata",
+            Self::NotFound(_) => "notfound",
+            Self::GetBlocks(_) => "getblocks",
+            Self::GetHeaders(_) => "getheaders",
+            Self::MemPool => "mempool",
+            Self::Tx(_) => "tx",
+            Self::Block(_) => "block",
+            Self::Headers(_) => "headers",
+            Self::SendHeaders => "sendheaders",
+            Self::GetAddr => "getaddr",
+            Self::Ping(_) => "ping",
+            Self::Pong(_) => "pong",
+            Self::MerkleBlock(_) => "merkleblock",
+            Self::FilterLoad(_) => "filterload",
+            Self::FilterAdd(_) => "filteradd",
+            Self::FilterClear => "filterclear",
+            Self::GetCFilters(_) => "getcfilters",
+            Self::CFilter(_) => "cfilter",
+            Self::GetCFHeaders(_) => "getcfheaders",
+            Self::CFHeaders(_) => "cfheaders",
+            Self::GetCFCheckpt(_) => "getcfcheckpt",
+            Self::CFCheckpt(_) => "cfcheckpt",
+            Self::SendCmpct(_) => "sendcmpct",
+            Self::CmpctBlock(_) => "cmpctblock",
+            Self::GetBlockTxn(_) => "getblocktxn",
+            Self::BlockTxn(_) => "blocktxn",
+            Self::Alert(_) => "alert",
+            Self::Reject(_) => "reject",
+            Self::FeeFilter(_) => "feefilter",
+            Self::WtxidRelay => "wtxidrelay",
+            Self::AddrV2(_) => "addrv2",
+            Self::SendAddrV2 => "sendaddrv2",
+            Self::Unknown { .. } => "unknown",
+        }
+    }
+
+    /// Returns the `CommandString` for the message command.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the command string is invalid (should never happen for valid message types).
+    pub fn command(&self) -> CommandString {
+        match *self {
+            Self::Unknown { command: ref c, .. } => c.clone(),
+            _ => CommandString::try_from_static(self.cmd()).expect("cmd returns valid commands"),
+        }
+    }
+}
+
+impl RawNetworkMessage {
+    /// Constructs a new [`RawNetworkMessage`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if message encoding fails or if the payload length exceeds `u32::MAX`.
+    pub fn new(magic: Magic, payload: NetworkMessage) -> Self {
+        let mut engine = sha256d::Hash::engine();
+        let payload_len = payload.consensus_encode(&mut engine).expect("engine doesn't error");
+        let payload_len = u32::try_from(payload_len).expect("network message use u32 as length");
+        let checksum = sha256d::Hash::from_engine(engine);
+        let checksum = checksum.to_byte_array();
+        let checksum = [checksum[0], checksum[1], checksum[2], checksum[3]];
+        Self { magic, payload, payload_len, checksum }
+    }
+
+    /// Consumes the [`RawNetworkMessage`] instance and returns the inner payload.
+    pub fn into_payload(self) -> NetworkMessage { self.payload }
+
+    /// The actual message data
+    pub fn payload(&self) -> &NetworkMessage { &self.payload }
+
+    /// Magic bytes to identify the network these messages are meant for
+    pub fn magic(&self) -> &Magic { &self.magic }
+
+    /// Returns the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [`NetworkMessage::Unknown`],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [`Self::command`] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
+
+    /// Returns the `CommandString` for the message command.
+    pub fn command(&self) -> CommandString { self.payload.command() }
+}
+
+impl V2NetworkMessage {
+    /// Constructs a new [`V2NetworkMessage`].
+    pub fn new(payload: NetworkMessage) -> Self { Self { payload } }
+
+    /// Consumes the [`V2NetworkMessage`] instance and returns the inner payload.
+    pub fn into_payload(self) -> NetworkMessage { self.payload }
+
+    /// The actual message data
+    pub fn payload(&self) -> &NetworkMessage { &self.payload }
+
+    /// Returns the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [`NetworkMessage::Unknown`],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [`Self::command`] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
+
+    /// Returns the `CommandString` for the message command.
+    pub fn command(&self) -> CommandString { self.payload.command() }
+}
+
+impl Encodable for HeadersMessage {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += w.emit_compact_size(self.0.len())?;
+        for header in &self.0 {
+            len += header.consensus_encode(w)?;
+            len += 0u8.consensus_encode(w)?;
+        }
+        Ok(len)
+    }
+}
+
+impl Encodable for NetworkMessage {
+    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
+        match self {
+            Self::Version(ref dat) => dat.consensus_encode(writer),
+            Self::Addr(ref dat) => dat.consensus_encode(writer),
+            Self::Inv(ref dat) => dat.consensus_encode(writer),
+            Self::GetData(ref dat) => dat.consensus_encode(writer),
+            Self::NotFound(ref dat) => dat.consensus_encode(writer),
+            Self::GetBlocks(ref dat) => dat.consensus_encode(writer),
+            Self::GetHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::Tx(ref dat) => dat.consensus_encode(writer),
+            Self::Block(ref dat) => dat.consensus_encode(writer),
+            Self::Headers(ref dat) => dat.consensus_encode(writer),
+            Self::Ping(ref dat) => dat.consensus_encode(writer),
+            Self::Pong(ref dat) => dat.consensus_encode(writer),
+            Self::MerkleBlock(ref dat) => dat.consensus_encode(writer),
+            Self::FilterLoad(ref dat) => dat.consensus_encode(writer),
+            Self::FilterAdd(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFilters(ref dat) => dat.consensus_encode(writer),
+            Self::CFilter(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::CFHeaders(ref dat) => dat.consensus_encode(writer),
+            Self::GetCFCheckpt(ref dat) => dat.consensus_encode(writer),
+            Self::CFCheckpt(ref dat) => dat.consensus_encode(writer),
+            Self::SendCmpct(ref dat) => dat.consensus_encode(writer),
+            Self::CmpctBlock(ref dat) => dat.consensus_encode(writer),
+            Self::GetBlockTxn(ref dat) => dat.consensus_encode(writer),
+            Self::BlockTxn(ref dat) => dat.consensus_encode(writer),
+            Self::Alert(ref dat) => dat.consensus_encode(writer),
+            Self::Reject(ref dat) => dat.consensus_encode(writer),
+            Self::FeeFilter(ref dat) => dat.consensus_encode(writer),
+            Self::AddrV2(ref dat) => dat.consensus_encode(writer),
+            Self::Verack
+            | Self::SendHeaders
+            | Self::MemPool
+            | Self::GetAddr
+            | Self::WtxidRelay
+            | Self::FilterClear
+            | Self::SendAddrV2 => Ok(0),
+            Self::Unknown { payload: ref data, .. } => data.consensus_encode(writer),
+        }
+    }
+}
+
+impl Encodable for RawNetworkMessage {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.magic.consensus_encode(w)?;
+        len += self.command().consensus_encode(w)?;
+        len += self.payload_len.consensus_encode(w)?;
+        len += self.checksum.consensus_encode(w)?;
+        len += self.payload().consensus_encode(w)?;
+        Ok(len)
+    }
+}
+
+struct NetworkMessageEncoder {
+    buffer: Vec<u8>,
+    exhausted: bool,
+}
+
+impl NetworkMessageEncoder {
+    fn new(msg: &NetworkMessage) -> Self {
+        let mut buffer = Vec::new();
+        // TODO: delegate to internal encoders once migrated to consensus_encoding.
+        bitcoin::consensus::encode::Encodable::consensus_encode(msg, &mut buffer)
+            .expect("encoding to vec cannot fail");
+        Self { buffer, exhausted: false }
+    }
+}
+
+impl encoding::Encoder for NetworkMessageEncoder {
+    fn current_chunk(&self) -> &[u8] {
+        if self.exhausted {
+            &[]
+        } else {
+            &self.buffer
+        }
+    }
+
+    fn advance(&mut self) -> bool {
+        self.exhausted = true;
+        false
+    }
+}
+
+encoding::encoder_newtype! {
+    /// Encoder for [`RawNetworkMessage`].
+    pub struct RawNetworkMessageEncoder(
+        encoding::Encoder2<
+            encoding::Encoder4<
+                encoding::ArrayEncoder<4>,
+                encoding::ArrayEncoder<12>,
+                encoding::ArrayEncoder<4>,
+                encoding::ArrayEncoder<4>,
+            >,
+            NetworkMessageEncoder,
+        >
+    );
+}
+
+impl encoding::Encodable for RawNetworkMessage {
+    type Encoder<'e> = RawNetworkMessageEncoder;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        RawNetworkMessageEncoder(encoding::Encoder2::new(
+            encoding::Encoder4::new(
+                encoding::ArrayEncoder::without_length_prefix(self.magic.to_bytes()),
+                self.command().encoder(),
+                encoding::ArrayEncoder::without_length_prefix(self.payload_len.to_le_bytes()),
+                encoding::ArrayEncoder::without_length_prefix(self.checksum),
+            ),
+            NetworkMessageEncoder::new(&self.payload),
+        ))
+    }
+}
+
+struct NetworkMessageDecoder {
+    command: CommandString,
+    payload_len: usize,
+    buffer: Vec<u8>,
+}
+
+impl NetworkMessageDecoder {
+    fn new(command: CommandString, payload_len: usize) -> Self {
+        Self { command, payload_len, buffer: Vec::new() }
+    }
+}
+
+impl encoding::Decoder for NetworkMessageDecoder {
+    type Output = NetworkMessage;
+    type Error = RawNetworkMessageDecodeError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        let remaining = self.payload_len - self.buffer.len();
+        let copy_len = bytes.len().min(remaining);
+
+        self.buffer.extend_from_slice(&bytes[..copy_len]);
+        *bytes = &bytes[copy_len..];
+
+        Ok(self.buffer.len() < self.payload_len)
+    }
+
+    #[allow(clippy::too_many_lines)]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let payload_bytes = self.buffer;
+
+        // Validate payload length matches actual data.
+        if payload_bytes.len() != self.payload_len {
+            return Err(RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload));
+        }
+
+        // TODO: delegate to internal decoders once migrated to consensus_encoding.
+        let mut mem_d = payload_bytes.as_slice();
+        let payload = match self.command.as_ref() {
+            "version" => NetworkMessage::Version(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "verack" => NetworkMessage::Verack,
+            "addr" => NetworkMessage::Addr(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "inv" => NetworkMessage::Inv(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getdata" => NetworkMessage::GetData(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "notfound" => NetworkMessage::NotFound(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getblocks" => NetworkMessage::GetBlocks(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getheaders" => NetworkMessage::GetHeaders(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "mempool" => NetworkMessage::MemPool,
+            "block" => NetworkMessage::Block(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "headers" => NetworkMessage::Headers(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "sendheaders" => NetworkMessage::SendHeaders,
+            "getaddr" => NetworkMessage::GetAddr,
+            "ping" => NetworkMessage::Ping(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "pong" => NetworkMessage::Pong(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "merkleblock" => NetworkMessage::MerkleBlock(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "filterload" => NetworkMessage::FilterLoad(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "filteradd" => NetworkMessage::FilterAdd(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "filterclear" => NetworkMessage::FilterClear,
+            "getcfilters" => NetworkMessage::GetCFilters(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "cfilter" => NetworkMessage::CFilter(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getcfheaders" => NetworkMessage::GetCFHeaders(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "cfheaders" => NetworkMessage::CFHeaders(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getcfcheckpt" => NetworkMessage::GetCFCheckpt(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "cfcheckpt" => NetworkMessage::CFCheckpt(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "sendcmpct" => NetworkMessage::SendCmpct(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "cmpctblock" => NetworkMessage::CmpctBlock(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "getblocktxn" => NetworkMessage::GetBlockTxn(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "blocktxn" => NetworkMessage::BlockTxn(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "tx" => NetworkMessage::Tx(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "alert" => NetworkMessage::Alert(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "reject" => NetworkMessage::Reject(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "feefilter" => NetworkMessage::FeeFilter(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "wtxidrelay" => NetworkMessage::WtxidRelay,
+            "addrv2" => NetworkMessage::AddrV2(
+                bitcoin::consensus::encode::Decodable::consensus_decode_from_finite_reader(
+                    &mut mem_d,
+                )
+                .map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Payload)
+                })?,
+            ),
+            "sendaddrv2" => NetworkMessage::SendAddrV2,
+            _ => NetworkMessage::Unknown { command: self.command, payload: payload_bytes },
+        };
+
+        Ok(payload)
+    }
+
+    fn read_limit(&self) -> usize { self.payload_len - self.buffer.len() }
+}
+
+enum DecoderState {
+    ReadingHeader {
+        header_decoder: encoding::Decoder4<
+            encoding::ArrayDecoder<4>,
+            CommandStringDecoder,
+            encoding::ArrayDecoder<4>,
+            encoding::ArrayDecoder<4>,
+        >,
+    },
+    ReadingPayload {
+        magic_bytes: [u8; 4],
+        payload_len_bytes: [u8; 4],
+        checksum: [u8; 4],
+        payload_decoder: NetworkMessageDecoder,
+    },
+}
+
+/// Decoder for [`RawNetworkMessage`].
+///
+/// This decoder implements a two-phase decoding process for Bitcoin V1 P2P messages.
+/// It first decodes the fixed-sized header. It then uses the payload length information
+/// to decode the dynamically sized network message.
+pub struct RawNetworkMessageDecoder {
+    state: DecoderState,
+}
+
+impl encoding::Decoder for RawNetworkMessageDecoder {
+    type Output = RawNetworkMessage;
+    type Error = RawNetworkMessageDecodeError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        match &mut self.state {
+            DecoderState::ReadingHeader { header_decoder } => {
+                let need_more = header_decoder.push_bytes(bytes).map_err(|_| {
+                    RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Header)
+                })?;
+
+                if !need_more {
+                    // Header complete, extract values and transition to payload state.
+                    let old_state = core::mem::replace(
+                        &mut self.state,
+                        DecoderState::ReadingHeader {
+                            header_decoder: encoding::Decoder4::new(
+                                encoding::ArrayDecoder::new(),
+                                CommandStringDecoder { inner: encoding::ArrayDecoder::new() },
+                                encoding::ArrayDecoder::new(),
+                                encoding::ArrayDecoder::new(),
+                            ),
+                        },
+                    );
+
+                    let DecoderState::ReadingHeader { header_decoder } = old_state else {
+                        unreachable!("we are in ReadingHeader state")
+                    };
+
+                    let (magic_bytes, command, payload_len_bytes, checksum) =
+                        header_decoder.end().map_err(|_| {
+                            RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Header)
+                        })?;
+
+                    let payload_len = u32::from_le_bytes(payload_len_bytes) as usize;
+                    if payload_len > MAX_MSG_SIZE {
+                        return Err(RawNetworkMessageDecodeError(
+                            RawNetworkMessageDecodeErrorInner::PayloadTooLarge,
+                        ));
+                    }
+
+                    let payload_decoder = NetworkMessageDecoder::new(command, payload_len);
+                    self.state = DecoderState::ReadingPayload {
+                        magic_bytes,
+                        payload_len_bytes,
+                        checksum,
+                        payload_decoder,
+                    };
+
+                    // Continue with any remaining bytes.
+                    return self.push_bytes(bytes);
+                }
+
+                Ok(need_more)
+            }
+            DecoderState::ReadingPayload { payload_decoder, .. } =>
+                payload_decoder.push_bytes(bytes),
+        }
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        match self.state {
+            DecoderState::ReadingHeader { .. } =>
+                Err(RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner::Header)),
+            DecoderState::ReadingPayload {
+                magic_bytes,
+                payload_len_bytes,
+                checksum,
+                payload_decoder,
+                ..
+            } => {
+                let payload = payload_decoder.end()?;
+
+                Ok(RawNetworkMessage {
+                    magic: Magic::from_bytes(magic_bytes),
+                    payload,
+                    payload_len: u32::from_le_bytes(payload_len_bytes),
+                    checksum,
+                })
+            }
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        match &self.state {
+            DecoderState::ReadingHeader { header_decoder } => header_decoder.read_limit(),
+            DecoderState::ReadingPayload { payload_decoder, .. } => payload_decoder.read_limit(),
+        }
+    }
+}
+
+impl encoding::Decodable for RawNetworkMessage {
+    type Decoder = RawNetworkMessageDecoder;
+
+    fn decoder() -> Self::Decoder {
+        RawNetworkMessageDecoder {
+            state: DecoderState::ReadingHeader {
+                header_decoder: encoding::Decoder4::new(
+                    encoding::ArrayDecoder::new(),
+                    CommandStringDecoder { inner: encoding::ArrayDecoder::new() },
+                    encoding::ArrayDecoder::new(),
+                    encoding::ArrayDecoder::new(),
+                ),
+            },
+        }
+    }
+}
+
+/// Error decoding a raw network message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RawNetworkMessageDecodeError(RawNetworkMessageDecodeErrorInner);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum RawNetworkMessageDecodeErrorInner {
+    /// Error decoding the message header.
+    Header,
+    /// Payload length exceeds maximum allowed message size.
+    PayloadTooLarge,
+    /// Error decoding the message payload.
+    Payload,
+}
+
+impl fmt::Display for RawNetworkMessageDecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.0 {
+            RawNetworkMessageDecodeErrorInner::Header => {
+                write!(f, "error decoding message header")
+            }
+            RawNetworkMessageDecodeErrorInner::PayloadTooLarge => {
+                write!(f, "payload length exceeds maximum allowed message size")
+            }
+            RawNetworkMessageDecodeErrorInner::Payload => {
+                write!(f, "error decoding message payload")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RawNetworkMessageDecodeError {}
+
+impl Encodable for V2NetworkMessage {
+    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
+        // A subset of message types are optimized to only use one byte to encode the command.
+        // Non-optimized message types use the zero-byte flag and the following twelve bytes to encode the command.
+        let (command_byte, full_command) = match self.payload {
+            NetworkMessage::Addr(_) => (1u8, None),
+            NetworkMessage::Inv(_) => (14u8, None),
+            NetworkMessage::GetData(_) => (11u8, None),
+            NetworkMessage::NotFound(_) => (17u8, None),
+            NetworkMessage::GetBlocks(_) => (9u8, None),
+            NetworkMessage::GetHeaders(_) => (12u8, None),
+            NetworkMessage::MemPool => (15u8, None),
+            NetworkMessage::Tx(_) => (21u8, None),
+            NetworkMessage::Block(_) => (2u8, None),
+            NetworkMessage::Headers(_) => (13u8, None),
+            NetworkMessage::Ping(_) => (18u8, None),
+            NetworkMessage::Pong(_) => (19u8, None),
+            NetworkMessage::MerkleBlock(_) => (16u8, None),
+            NetworkMessage::FilterLoad(_) => (8u8, None),
+            NetworkMessage::FilterAdd(_) => (6u8, None),
+            NetworkMessage::FilterClear => (7u8, None),
+            NetworkMessage::GetCFilters(_) => (22u8, None),
+            NetworkMessage::CFilter(_) => (23u8, None),
+            NetworkMessage::GetCFHeaders(_) => (24u8, None),
+            NetworkMessage::CFHeaders(_) => (25u8, None),
+            NetworkMessage::GetCFCheckpt(_) => (26u8, None),
+            NetworkMessage::CFCheckpt(_) => (27u8, None),
+            NetworkMessage::SendCmpct(_) => (20u8, None),
+            NetworkMessage::CmpctBlock(_) => (4u8, None),
+            NetworkMessage::GetBlockTxn(_) => (10u8, None),
+            NetworkMessage::BlockTxn(_) => (3u8, None),
+            NetworkMessage::FeeFilter(_) => (5u8, None),
+            NetworkMessage::AddrV2(_) => (28u8, None),
+            NetworkMessage::Version(_)
+            | NetworkMessage::Verack
+            | NetworkMessage::SendHeaders
+            | NetworkMessage::GetAddr
+            | NetworkMessage::WtxidRelay
+            | NetworkMessage::SendAddrV2
+            | NetworkMessage::Alert(_)
+            | NetworkMessage::Reject(_)
+            | NetworkMessage::Unknown { .. } => (0u8, Some(self.payload.command())),
+        };
+
+        let mut len = command_byte.consensus_encode(writer)?;
+        if let Some(cmd) = full_command {
+            len += cmd.consensus_encode(writer)?;
+        }
+
+        // Encode the payload.
+        len += self.payload.consensus_encode(writer)?;
+
+        Ok(len)
+    }
+}
+
+/// A list of bitcoin block headers.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HeadersMessage(pub Vec<block::Header>);
+
+impl HeadersMessage {
+    /// Does each header point to the previous block hash in the list.
+    pub fn is_connected(&self) -> bool {
+        self.0
+            .iter()
+            .zip(self.0.iter().skip(1))
+            .all(|(first, second)| first.block_hash().eq(&second.prev_blockhash))
+    }
+}
+
+impl Decodable for HeadersMessage {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let len = r.read_compact_size()?;
+        // should be above usual number of items to avoid
+        // allocation
+        let mut ret = Vec::with_capacity(core::cmp::min(1024 * 16, len as usize));
+        for _ in 0..len {
+            ret.push(Decodable::consensus_decode(r)?);
+            if u8::consensus_decode(r)? != 0u8 {
+                return Err(crate::consensus::parse_failed_error(
+                    "Headers message should not contain transactions",
+                ));
+            }
+        }
+        Ok(Self(ret))
+    }
+
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
+    }
+}
+
+impl Decodable for RawNetworkMessage {
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let magic = Decodable::consensus_decode_from_finite_reader(r)?;
+        let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
+        let checked_data = CheckedData::consensus_decode_from_finite_reader(r)?;
+        let checksum = checked_data.checksum();
+        let raw_payload = checked_data.into_data();
+        let payload_len = raw_payload.len() as u32;
+
+        let mut mem_d = raw_payload.as_slice();
+        let payload = match &cmd.0[..] {
+            "version" =>
+                NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "verack" => NetworkMessage::Verack,
+            "addr" =>
+                NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "inv" =>
+                NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getdata" =>
+                NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "notfound" => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(
+                &mut mem_d,
+            )?),
+            "getblocks" => NetworkMessage::GetBlocks(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getheaders" => NetworkMessage::GetHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "mempool" => NetworkMessage::MemPool,
+            "block" =>
+                NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "headers" => NetworkMessage::Headers(
+                HeadersMessage::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "sendheaders" => NetworkMessage::SendHeaders,
+            "getaddr" => NetworkMessage::GetAddr,
+            "ping" =>
+                NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "pong" =>
+                NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "merkleblock" => NetworkMessage::MerkleBlock(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filterload" => NetworkMessage::FilterLoad(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filteradd" => NetworkMessage::FilterAdd(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filterclear" => NetworkMessage::FilterClear,
+            "tx" => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getcfilters" => NetworkMessage::GetCFilters(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfilter" =>
+                NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getcfheaders" => NetworkMessage::GetCFHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfheaders" => NetworkMessage::CFHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getcfcheckpt" => NetworkMessage::GetCFCheckpt(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfcheckpt" => NetworkMessage::CFCheckpt(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "reject" =>
+                NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "alert" =>
+                NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "feefilter" => NetworkMessage::FeeFilter(
+                FeeFilter::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "sendcmpct" => NetworkMessage::SendCmpct(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cmpctblock" => NetworkMessage::CmpctBlock(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getblocktxn" => NetworkMessage::GetBlockTxn(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "blocktxn" => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(
+                &mut mem_d,
+            )?),
+            "wtxidrelay" => NetworkMessage::WtxidRelay,
+            "addrv2" =>
+                NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "sendaddrv2" => NetworkMessage::SendAddrV2,
+            _ => NetworkMessage::Unknown { command: cmd, payload: raw_payload },
+        };
+        Ok(Self { magic, payload, payload_len, checksum })
+    }
+
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
+    }
+}
+
+impl Decodable for V2NetworkMessage {
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let short_id: u8 = Decodable::consensus_decode_from_finite_reader(r)?;
+        let payload = match short_id {
+            0u8 => {
+                // Full command encoding.
+                let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
+                match &cmd.0[..] {
+                    "version" =>
+                        NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(r)?),
+                    "verack" => NetworkMessage::Verack,
+                    "sendheaders" => NetworkMessage::SendHeaders,
+                    "getaddr" => NetworkMessage::GetAddr,
+                    "wtxidrelay" => NetworkMessage::WtxidRelay,
+                    "sendaddrv2" => NetworkMessage::SendAddrV2,
+                    "alert" =>
+                        NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(r)?),
+                    "reject" =>
+                        NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(r)?),
+                    _ => NetworkMessage::Unknown {
+                        command: cmd,
+                        payload: Vec::consensus_decode_from_finite_reader(r)?,
+                    },
+                }
+            }
+            1u8 => NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(r)?),
+            2u8 => NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(r)?),
+            3u8 => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
+            4u8 => NetworkMessage::CmpctBlock(Decodable::consensus_decode_from_finite_reader(r)?),
+            5u8 => NetworkMessage::FeeFilter(FeeFilter::consensus_decode_from_finite_reader(r)?),
+            6u8 => NetworkMessage::FilterAdd(Decodable::consensus_decode_from_finite_reader(r)?),
+            7u8 => NetworkMessage::FilterClear,
+            8u8 => NetworkMessage::FilterLoad(Decodable::consensus_decode_from_finite_reader(r)?),
+            9u8 => NetworkMessage::GetBlocks(Decodable::consensus_decode_from_finite_reader(r)?),
+            10u8 => NetworkMessage::GetBlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
+            11u8 => NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(r)?),
+            12u8 => NetworkMessage::GetHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            13u8 =>
+                NetworkMessage::Headers(HeadersMessage::consensus_decode_from_finite_reader(r)?),
+            14u8 => NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(r)?),
+            15u8 => NetworkMessage::MemPool,
+            16u8 => NetworkMessage::MerkleBlock(Decodable::consensus_decode_from_finite_reader(r)?),
+            17u8 => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(r)?),
+            18u8 => NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(r)?),
+            19u8 => NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(r)?),
+            20u8 => NetworkMessage::SendCmpct(Decodable::consensus_decode_from_finite_reader(r)?),
+            21u8 => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(r)?),
+            22u8 => NetworkMessage::GetCFilters(Decodable::consensus_decode_from_finite_reader(r)?),
+            23u8 => NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(r)?),
+            24u8 =>
+                NetworkMessage::GetCFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            25u8 => NetworkMessage::CFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            26u8 =>
+                NetworkMessage::GetCFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
+            27u8 => NetworkMessage::CFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
+            28u8 => NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(r)?),
+            _ =>
+                return Err(encode::Error::Parse(encode::ParseError::ParseFailed(
+                    "Unknown short ID",
+                ))),
+        };
+        Ok(Self { payload })
+    }
+
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
+    }
+}
+
+/// Data and a 4-byte checksum.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CheckedData {
+    data: Vec<u8>,
+    checksum: [u8; 4],
+}
+
+impl CheckedData {
+    /// Constructs a new `CheckedData` computing the checksum of given data.
+    pub fn new(data: Vec<u8>) -> Self {
+        let checksum = sha2_checksum(&data);
+        Self { data, checksum }
+    }
+
+    /// Returns a reference to the raw data without the checksum.
+    pub fn data(&self) -> &[u8] { &self.data }
+
+    /// Returns the raw data without the checksum.
+    pub fn into_data(self) -> Vec<u8> { self.data }
+
+    /// Returns the checksum of the data.
+    pub fn checksum(&self) -> [u8; 4] { self.checksum }
+}
+
+impl Encodable for CheckedData {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        u32::try_from(self.data.len())
+            .expect("network message use u32 as length")
+            .consensus_encode(w)?;
+        self.checksum().consensus_encode(w)?;
+        Ok(8 + w.emit_slice(&self.data)?)
+    }
+}
+
+impl Decodable for CheckedData {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let len = u32::consensus_decode_from_finite_reader(r)? as usize;
+
+        let checksum = <[u8; 4]>::consensus_decode_from_finite_reader(r)?;
+        let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: encode::MAX_VEC_SIZE };
+        let data = read_bytes_from_finite_reader(r, opts)?;
+        let expected_checksum = sha2_checksum(&data);
+        if expected_checksum == checksum {
+            Ok(Self { data, checksum })
+        } else {
+            Err(encode::ParseError::InvalidChecksum {
+                expected: expected_checksum,
+                actual: checksum,
+            }
+            .into())
+        }
+    }
+}
+
+struct ReadBytesFromFiniteReaderOpts {
+    len: usize,
+    chunk_size: usize,
+}
+
+/// Read `opts.len` bytes from reader, where `opts.len` could potentially be malicious.
+///
+/// This function relies on reader being bound in amount of data
+/// it returns for OOM protection. See [`Decodable::consensus_decode_from_finite_reader`].
+#[inline]
+fn read_bytes_from_finite_reader<D: Read + ?Sized>(
+    d: &mut D,
+    mut opts: ReadBytesFromFiniteReaderOpts,
+) -> Result<Vec<u8>, encode::Error> {
+    let mut ret = vec![];
+
+    assert_ne!(opts.chunk_size, 0);
+
+    while opts.len > 0 {
+        let chunk_start = ret.len();
+        let chunk_size = cmp::min(opts.len, opts.chunk_size);
+        let chunk_end = chunk_start + chunk_size;
+        ret.resize(chunk_end, 0u8);
+        d.read_slice(&mut ret[chunk_start..chunk_end])?;
+        opts.len -= chunk_size;
+    }
+
+    Ok(ret)
+}
+
+/// Does a double-SHA256 on `data` and returns the first 4 bytes.
+fn sha2_checksum(data: &[u8]) -> [u8; 4] {
+    let checksum = sha256d::hash(data);
+    let checksum = checksum.to_byte_array();
+    [checksum[0], checksum[1], checksum[2], checksum[3]]
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for AddrPayload {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self(Vec::<(u32, Address)>::arbitrary(u)?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for AddrV2Payload {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self(Vec::<AddrV2Message>::arbitrary(u)?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for InventoryPayload {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self(Vec::<message_blockdata::Inventory>::arbitrary(u)?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for CommandString {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self(u.arbitrary::<String>()?.into()))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for HeadersMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> { Ok(Self(u.arbitrary()?)) }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for NetworkMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=36)? {
+            0 => Ok(Self::Version(u.arbitrary()?)),
+            1 => Ok(Self::Verack),
+            2 => Ok(Self::Addr(u.arbitrary()?)),
+            3 => Ok(Self::Inv(u.arbitrary()?)),
+            4 => Ok(Self::GetData(u.arbitrary()?)),
+            5 => Ok(Self::NotFound(u.arbitrary()?)),
+            6 => Ok(Self::GetBlocks(u.arbitrary()?)),
+            7 => Ok(Self::GetHeaders(u.arbitrary()?)),
+            8 => Ok(Self::MemPool),
+            9 => Ok(Self::Tx(u.arbitrary()?)),
+            10 => Ok(Self::Block(u.arbitrary()?)),
+            11 => Ok(Self::Headers(u.arbitrary()?)),
+            12 => Ok(Self::SendHeaders),
+            13 => Ok(Self::GetAddr),
+            14 => Ok(Self::Ping(u.arbitrary()?)),
+            15 => Ok(Self::Pong(u.arbitrary()?)),
+            16 => Ok(Self::MerkleBlock(u.arbitrary()?)),
+            17 => Ok(Self::FilterLoad(u.arbitrary()?)),
+            18 => Ok(Self::FilterAdd(u.arbitrary()?)),
+            19 => Ok(Self::FilterClear),
+            20 => Ok(Self::GetCFilters(u.arbitrary()?)),
+            21 => Ok(Self::CFilter(u.arbitrary()?)),
+            22 => Ok(Self::GetCFHeaders(u.arbitrary()?)),
+            23 => Ok(Self::CFHeaders(u.arbitrary()?)),
+            24 => Ok(Self::GetCFCheckpt(u.arbitrary()?)),
+            25 => Ok(Self::CFCheckpt(u.arbitrary()?)),
+            26 => Ok(Self::SendCmpct(u.arbitrary()?)),
+            27 => Ok(Self::CmpctBlock(u.arbitrary()?)),
+            28 => Ok(Self::GetBlockTxn(u.arbitrary()?)),
+            29 => Ok(Self::BlockTxn(u.arbitrary()?)),
+            30 => Ok(Self::Alert(u.arbitrary()?)),
+            31 => Ok(Self::Reject(u.arbitrary()?)),
+            32 => Ok(Self::FeeFilter(u.arbitrary()?)),
+            33 => Ok(Self::WtxidRelay),
+            34 => Ok(Self::AddrV2(u.arbitrary()?)),
+            35 => Ok(Self::SendAddrV2),
+            _ => Ok(Self::Unknown { command: u.arbitrary()?, payload: Vec::<u8>::arbitrary(u)? }),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for RawNetworkMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::new(u.arbitrary()?, u.arbitrary()?))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use alloc::string::ToString;
+    use alloc::vec;
+    use std::net::Ipv4Addr;
+
+    use bitcoin::consensus::encode::{deserialize, deserialize_partial, serialize};
+    use hex_lit::hex;
+    use primitives::transaction::{Transaction, Txid};
+    use primitives::{Block, BlockHash};
+    use units::BlockHeight;
+
+    use super::*;
+    use crate::address::AddrV2;
+    use crate::bip152::BlockTransactionsRequest;
+    use crate::message_blockdata::{GetBlocksMessage, GetHeadersMessage, Inventory};
+    use crate::message_bloom::{BloomFlags, FilterAdd, FilterLoad};
+    use crate::message_compact_blocks::{GetBlockTxn, SendCmpct};
+    use crate::message_filter::{
+        CFCheckpt, CFHeaders, CFilter, FilterHash, FilterHeader, GetCFCheckpt, GetCFHeaders,
+        GetCFilters,
+    };
+    use crate::message_network::{Alert, Reject, RejectReason, VersionMessage};
+    use crate::{ProtocolVersion, ServiceFlags};
+
+    fn hash(array: [u8; 32]) -> sha256d::Hash { sha256d::Hash::from_byte_array(array) }
+
+    #[test]
+    #[allow(clippy::too_many_lines)]
+    fn full_round_ser_der_raw_network_message() {
+        let version_msg: VersionMessage = deserialize(&hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001")).unwrap();
+        let tx: Transaction = deserialize(&hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000")).unwrap();
+        let block: Block = deserialize(&hex!("00608e2e094d41aecfbcbf8fe70cb60be57516b07db1bafee4c4de5dad760000000000004aec16eab3be95abe9c54e01cf850c14b8c5cad1bc6b2e73e811db5d5998ada404503e66fcff031b4ebd99d701010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff3402983a000404503e6604f1f617271083bc3d6600000000000000000007bb1b0a636b706f6f6c0d506f72746c616e642e484f444cffffffff0200f2052a010000001976a9142ce72b25fe97b52638c199acfaa5e3891ddfed5b88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap();
+        let header: block::Header = deserialize(&hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b")).unwrap();
+        let script = &hex!("1976a91431a420903c05a0a7de2de40c9f02ebedbacdc17288ac");
+        let merkle_block: MerkleBlock = deserialize(&hex!("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101")).unwrap();
+        let cmptblock = deserialize(&hex!("00000030d923ad36ff2d955abab07f8a0a6e813bc6e066b973e780c5e36674cad5d1cd1f6e265f2a17a0d35cbe701fe9d06e2c6324cfe135f6233e8b767bfa3fb4479b71115dc562ffff7f2006000000000000000000000000010002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0302ee00ffffffff0100f9029500000000015100000000")).unwrap();
+        let blocktxn = deserialize(&hex!("2e93c0cff39ff605020072d96bc3a8d20b8447e294d08092351c8583e08d9b5a01020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0402dc0000ffffffff0200f90295000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap();
+
+        let msgs = [
+            NetworkMessage::Version(version_msg),
+            NetworkMessage::Verack,
+            NetworkMessage::Addr(AddrPayload(vec![(
+                45,
+                Address::new(&([123, 255, 000, 100], 833).into(), ServiceFlags::NETWORK),
+            )])),
+            NetworkMessage::Inv(InventoryPayload(vec![Inventory::Block(
+                BlockHash::from_byte_array(hash([8u8; 32]).to_byte_array()),
+            )])),
+            NetworkMessage::GetData(InventoryPayload(vec![Inventory::Transaction(
+                Txid::from_byte_array(hash([45u8; 32]).to_byte_array()),
+            )])),
+            NetworkMessage::NotFound(InventoryPayload(vec![Inventory::Error([0u8; 32])])),
+            NetworkMessage::GetBlocks(GetBlocksMessage {
+                version: ProtocolVersion::from_nonstandard(70001),
+                locator_hashes: vec![
+                    BlockHash::from_byte_array(hash([1u8; 32]).to_byte_array()),
+                    BlockHash::from_byte_array(hash([4u8; 32]).to_byte_array()),
+                ],
+                stop_hash: BlockHash::from_byte_array(hash([5u8; 32]).to_byte_array()),
+            }),
+            NetworkMessage::GetHeaders(GetHeadersMessage {
+                version: ProtocolVersion::from_nonstandard(70001),
+                locator_hashes: vec![
+                    BlockHash::from_byte_array(hash([10u8; 32]).to_byte_array()),
+                    BlockHash::from_byte_array(hash([40u8; 32]).to_byte_array()),
+                ],
+                stop_hash: BlockHash::from_byte_array(hash([50u8; 32]).to_byte_array()),
+            }),
+            NetworkMessage::MemPool,
+            NetworkMessage::Tx(tx),
+            NetworkMessage::Block(block),
+            NetworkMessage::Headers(HeadersMessage(vec![header])),
+            NetworkMessage::SendHeaders,
+            NetworkMessage::GetAddr,
+            NetworkMessage::Ping(15),
+            NetworkMessage::Pong(23),
+            NetworkMessage::MerkleBlock(merkle_block),
+            NetworkMessage::FilterLoad(FilterLoad {
+                filter: hex!("03614e9b050000000000000001").to_vec(),
+                hash_funcs: 1,
+                tweak: 2,
+                flags: BloomFlags::All,
+            }),
+            NetworkMessage::FilterAdd(FilterAdd { data: script.to_vec() }),
+            NetworkMessage::FilterAdd(FilterAdd {
+                data: hash([29u8; 32]).as_byte_array().to_vec(),
+            }),
+            NetworkMessage::FilterClear,
+            NetworkMessage::GetCFilters(GetCFilters {
+                filter_type: 2,
+                start_height: BlockHeight::from(52),
+                stop_hash: BlockHash::from_byte_array(hash([42u8; 32]).to_byte_array()),
+            }),
+            NetworkMessage::CFilter(CFilter {
+                filter_type: 7,
+                block_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
+                filter: vec![1, 2, 3],
+            }),
+            NetworkMessage::GetCFHeaders(GetCFHeaders {
+                filter_type: 4,
+                start_height: BlockHeight::from(102),
+                stop_hash: BlockHash::from_byte_array(hash([47u8; 32]).to_byte_array()),
+            }),
+            NetworkMessage::CFHeaders(CFHeaders {
+                filter_type: 13,
+                stop_hash: BlockHash::from_byte_array(hash([53u8; 32]).to_byte_array()),
+                previous_filter_header: FilterHeader::from_byte_array(
+                    hash([12u8; 32]).to_byte_array(),
+                ),
+                filter_hashes: vec![
+                    FilterHash::from_byte_array(hash([4u8; 32]).to_byte_array()),
+                    FilterHash::from_byte_array(hash([12u8; 32]).to_byte_array()),
+                ],
+            }),
+            NetworkMessage::GetCFCheckpt(GetCFCheckpt {
+                filter_type: 17,
+                stop_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
+            }),
+            NetworkMessage::CFCheckpt(CFCheckpt {
+                filter_type: 27,
+                stop_hash: BlockHash::from_byte_array(hash([77u8; 32]).to_byte_array()),
+                filter_headers: vec![
+                    FilterHeader::from_byte_array(hash([3u8; 32]).to_byte_array()),
+                    FilterHeader::from_byte_array(hash([99u8; 32]).to_byte_array()),
+                ],
+            }),
+            NetworkMessage::Alert(Alert::final_alert()),
+            NetworkMessage::Reject(Reject {
+                message: "Test reject".into(),
+                ccode: RejectReason::Duplicate,
+                reason: "Cause".into(),
+                hash: hash([255u8; 32]),
+            }),
+            NetworkMessage::FeeFilter(FeeFilter::from(FeeRate::BROADCAST_MIN)),
+            NetworkMessage::WtxidRelay,
+            NetworkMessage::AddrV2(AddrV2Payload(vec![AddrV2Message {
+                addr: AddrV2::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
+                port: 0,
+                services: ServiceFlags::NONE,
+                time: 0,
+            }])),
+            NetworkMessage::SendAddrV2,
+            NetworkMessage::CmpctBlock(cmptblock),
+            NetworkMessage::GetBlockTxn(GetBlockTxn {
+                txs_request: BlockTransactionsRequest {
+                    block_hash: BlockHash::from_byte_array(hash([11u8; 32]).to_byte_array()),
+                    indexes: vec![0, 1, 2, 3, 10, 3002],
+                },
+            }),
+            NetworkMessage::BlockTxn(blocktxn),
+            NetworkMessage::SendCmpct(SendCmpct { send_compact: true, version: 8333 }),
+        ];
+
+        for msg in &msgs {
+            // V1 messages.
+            let raw_msg = RawNetworkMessage::new(Magic::from_bytes([57, 0, 0, 0]), msg.clone());
+            assert_eq!(deserialize::<RawNetworkMessage>(&serialize(&raw_msg)).unwrap(), raw_msg);
+
+            // V2 messages.
+            let v2_msg = V2NetworkMessage::new(msg.clone());
+            assert_eq!(deserialize::<V2NetworkMessage>(&serialize(&v2_msg)).unwrap(), v2_msg);
+        }
+    }
+
+    #[test]
+    fn commandstring() {
+        // Test converting.
+        assert_eq!(
+            CommandString::try_from_static("AndrewAndrew").unwrap().as_ref(),
+            "AndrewAndrew"
+        );
+        assert!(CommandString::try_from_static("AndrewAndrewA").is_err());
+
+        // Test serializing.
+        let cs = CommandString("Andrew".into());
+        assert_eq!(serialize(&cs), [0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
+
+        // Test deserializing
+        let cs: Result<CommandString, _> =
+            deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
+        assert!(cs.is_ok());
+        assert_eq!(cs.as_ref().unwrap().to_string(), "Andrew".to_owned());
+        assert_eq!(cs.unwrap(), CommandString::try_from_static("Andrew").unwrap());
+
+        // Test that embedded null bytes are preserved while trailing nulls are trimmed
+        let cs: Result<CommandString, _> =
+            deserialize(&[0, 0x41u8, 0x6e, 0x64, 0, 0x72, 0x65, 0x77, 0, 0, 0, 0]);
+        assert!(cs.is_ok());
+        assert_eq!(cs.as_ref().unwrap().to_string(), "\0And\0rew".to_owned());
+        assert_eq!(cs.unwrap(), CommandString::try_from_static("\0And\0rew").unwrap());
+
+        // Invalid CommandString, must be ASCII
+        assert!(deserialize::<CommandString>(&[
+            0, 0x41u8, 0x6e, 0xa4, 0, 0x72, 0x65, 0x77, 0, 0, 0, 0
+        ])
+        .is_err());
+
+        // Invalid CommandString, must be 12 bytes
+        assert!(deserialize::<CommandString>(&[
+            0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0
+        ])
+        .is_err());
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_verack() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::Verack)),
+                       [0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x61,
+                        0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    fn serialize_v2_verack() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::Verack)),
+            [
+                0x00, // Full command encoding flag.
+                0x76, 0x65, 0x72, 0x61, 0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_ping() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::Ping(100))),
+                       [0xf9, 0xbe, 0xb4, 0xd9, 0x70, 0x69, 0x6e, 0x67,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
+                        0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    #[test]
+    fn serialize_v2_ping() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::Ping(100))),
+            [
+                0x12, // Ping command short ID
+                0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_mempool() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::MemPool)),
+                       [0xf9, 0xbe, 0xb4, 0xd9, 0x6d, 0x65, 0x6d, 0x70,
+                        0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    fn serialize_v2_mempool() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::MemPool)),
+            [
+                0x0F, // MemPool command short ID
+            ]
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_getaddr() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::GetAddr)),
+                       [0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
+                        0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    fn serialize_v2_getaddr() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::GetAddr)),
+            [
+                0x00, // Full command encoding flag.
+                0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
+    #[test]
+    fn deserialize_getaddr() {
+        #[rustfmt::skip]
+        let msg = deserialize(&[
+            0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
+            0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2
+        ]);
+        let preimage = RawNetworkMessage::new(Magic::BITCOIN, NetworkMessage::GetAddr);
+        assert!(msg.is_ok());
+        let msg: RawNetworkMessage = msg.unwrap();
+        assert_eq!(preimage.magic, msg.magic);
+        assert_eq!(preimage.payload, msg.payload);
+    }
+
+    #[test]
+    fn deserialize_v2_getaddr() {
+        let msg = deserialize(&[
+            0x00, // Full command encoding flag
+            0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ]);
+
+        let preimage = V2NetworkMessage::new(NetworkMessage::GetAddr);
+        assert!(msg.is_ok());
+        let msg: V2NetworkMessage = msg.unwrap();
+        assert_eq!(preimage, msg);
+    }
+
+    #[test]
+    fn deserialize_version() {
+        #[rustfmt::skip]
+        let msg = deserialize::<RawNetworkMessage>(&[
+            0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
+            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
+            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
+            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
+            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01
+        ]);
+
+        assert!(msg.is_ok());
+        let msg = msg.unwrap();
+        assert_eq!(msg.magic, Magic::BITCOIN);
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, ProtocolVersion::INVALID_CB_NO_BAN_VERSION);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1_548_554_224);
+            assert_eq!(version_msg.nonce, 13_952_548_347_456_104_954);
+            assert_eq!(version_msg.user_agent.to_string(), "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560_275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("wrong message type");
+        }
+    }
+
+    #[test]
+    fn deserialize_v2_version() {
+        #[rustfmt::skip]
+        let msg = deserialize::<V2NetworkMessage>(&[
+            0x00, // Full command encoding flag
+            0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, // "version" command
+            0x7f, 0x11, 0x01, 0x00, // version: 70015
+            0x0d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // services
+            0xf0, 0x0f, 0x4d, 0x5c, 0x00, 0x00, 0x00, 0x00, // timestamp: 1_548_554_224
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // receiver services: NONE
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, // addr_recv
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sender services: NONE
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // addr_from
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1, // nonce
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31, 0x2f, // user_agent: "/Satoshi:0.17.1/"
+            0x93, 0x8c, 0x08, 0x00, // start_height: 560_275
+            0x01 // relay: true
+        ]).unwrap();
+
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, ProtocolVersion::INVALID_CB_NO_BAN_VERSION);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1_548_554_224);
+            assert_eq!(version_msg.nonce, 13_952_548_347_456_104_954);
+            assert_eq!(version_msg.user_agent.to_string(), "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560_275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("wrong message type");
+        }
+    }
+
+    #[test]
+    fn deserialize_partial_message() {
+        #[rustfmt::skip]
+        let data = [
+            0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
+            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
+            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
+            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
+            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01, 0x00, 0x00
+        ];
+        let msg = deserialize_partial::<RawNetworkMessage>(&data);
+        assert!(msg.is_ok());
+
+        let (msg, consumed) = msg.unwrap();
+        assert_eq!(consumed, data.to_vec().len() - 2);
+        assert_eq!(msg.magic, Magic::BITCOIN);
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, ProtocolVersion::INVALID_CB_NO_BAN_VERSION);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1_548_554_224);
+            assert_eq!(version_msg.nonce, 13_952_548_347_456_104_954);
+            assert_eq!(version_msg.user_agent.to_string(), "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560_275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("wrong message type");
+        }
+    }
+
+    #[test]
+    fn serialize_checkeddata() {
+        let cd = CheckedData::new(vec![1u8, 2, 3, 4, 5]);
+        assert_eq!(serialize(&cd), [5, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn deserialize_checkeddata() {
+        let cd: Result<CheckedData, _> =
+            deserialize(&[5u8, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
+        assert_eq!(cd.ok(), Some(CheckedData::new(vec![1u8, 2, 3, 4, 5])));
+    }
+
+    #[test]
+    fn headers_message() {
+        let block_900_000 = deserialize::<block::Header>(
+            &hex!("00a0ab20247d4d9f582f9750344cdf62c46d81d046be960340960100000000000000000070f96945530651135839d8adc3f40e595118ec74c7ad81a3d17bb022e554fb0c937f4268743702177ad05f92")
+        ).unwrap();
+        let block_900_001 = deserialize::<block::Header>(
+            &hex!("00e000208a96960d6d1ca4ee4a283fd83da309b8d5d2bfed380501000000000000000000371c9ffd63d75fb36c57d58eb842d23c0e7ec049daf16d94cc38805c346e9d52e880426874370217973dc83b")
+        ).unwrap();
+        let block_900_002 = deserialize::<block::Header>(
+            &hex!("0400ff3ffc834fac4e1eb2ae41f1f9776e0f8e24a6090603ffa8010000000000000000002efba7e7280aa60f0a650f29e30332d52e11af57bc58cc6e71f343851f016c676182426874370217e3615653")
+        ).unwrap();
+        let headers_message = HeadersMessage(vec![block_900_000, block_900_001, block_900_002]);
+        assert!(headers_message.is_connected());
+    }
+}
diff --git a/bitcoin/src/p2p/message_blockdata.rs b/p2p/src/message_blockdata.rs
similarity index 55%
rename from bitcoin/src/p2p/message_blockdata.rs
rename to p2p/src/message_blockdata.rs
index 3d92312043..3db68a2738 100644
--- a/bitcoin/src/p2p/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -5,13 +5,17 @@
 //! This module describes network messages which are used for passing
 //! Bitcoin data (blocks and transactions) around.
 
+use alloc::vec::Vec;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::encode::{self, Decodable, Encodable};
 use io::{BufRead, Write};
+use primitives::transaction::{Txid, Wtxid};
+use primitives::BlockHash;
 
-use crate::block::BlockHash;
-use crate::consensus::encode::{self, Decodable, Encodable};
-use crate::internal_macros::impl_consensus_encoding;
-use crate::p2p;
-use crate::transaction::{Txid, Wtxid};
+use crate::consensus::impl_consensus_encoding;
+use crate::ProtocolVersion;
 
 /// An inventory item.
 #[derive(PartialEq, Eq, Clone, Debug, Copy, Hash, PartialOrd, Ord)]
@@ -41,19 +45,19 @@ pub enum Inventory {
 }
 
 impl Inventory {
-    /// Return the item value represented as a SHA256-d hash.
+    /// Returns the item value represented as a SHA256-d hash.
     ///
-    /// Returns [None] only for [Inventory::Error] who's hash value is meaningless.
+    /// Returns [None] only for [`Inventory::Error`] who's hash value is meaningless.
     pub fn network_hash(&self) -> Option<[u8; 32]> {
         match self {
-            Inventory::Error(_) => None,
-            Inventory::Transaction(t) => Some(t.to_byte_array()),
-            Inventory::Block(b) => Some(b.to_byte_array()),
-            Inventory::CompactBlock(b) => Some(b.to_byte_array()),
-            Inventory::WTx(t) => Some(t.to_byte_array()),
-            Inventory::WitnessTransaction(t) => Some(t.to_byte_array()),
-            Inventory::WitnessBlock(b) => Some(b.to_byte_array()),
-            Inventory::Unknown { hash, .. } => Some(*hash),
+            Self::Error(_) => None,
+            Self::Transaction(t) => Some(t.to_byte_array()),
+            Self::Block(b) => Some(b.to_byte_array()),
+            Self::CompactBlock(b) => Some(b.to_byte_array()),
+            Self::WTx(t) => Some(t.to_byte_array()),
+            Self::WitnessTransaction(t) => Some(t.to_byte_array()),
+            Self::WitnessBlock(b) => Some(b.to_byte_array()),
+            Self::Unknown { hash, .. } => Some(*hash),
         }
     }
 }
@@ -67,14 +71,14 @@ impl Encodable for Inventory {
             };
         }
         Ok(match *self {
-            Inventory::Error(_) => encode_inv!(0, [0; 32]),
-            Inventory::Transaction(ref t) => encode_inv!(1, t),
-            Inventory::Block(ref b) => encode_inv!(2, b),
-            Inventory::CompactBlock(ref b) => encode_inv!(4, b),
-            Inventory::WTx(ref w) => encode_inv!(5, w),
-            Inventory::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
-            Inventory::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
-            Inventory::Unknown { inv_type: t, hash: ref d } => encode_inv!(t, d),
+            Self::Error(ref e) => encode_inv!(0, e),
+            Self::Transaction(ref t) => encode_inv!(1, t),
+            Self::Block(ref b) => encode_inv!(2, b),
+            Self::CompactBlock(ref b) => encode_inv!(4, b),
+            Self::WTx(ref w) => encode_inv!(5, w),
+            Self::WitnessTransaction(ref t) => encode_inv!(0x4000_0001, t),
+            Self::WitnessBlock(ref b) => encode_inv!(0x4000_0002, b),
+            Self::Unknown { inv_type: t, hash: ref d } => encode_inv!(t, d),
         })
     }
 }
@@ -84,14 +88,14 @@ impl Decodable for Inventory {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         let inv_type: u32 = Decodable::consensus_decode(r)?;
         Ok(match inv_type {
-            0 => Inventory::Error(Decodable::consensus_decode(r)?),
-            1 => Inventory::Transaction(Decodable::consensus_decode(r)?),
-            2 => Inventory::Block(Decodable::consensus_decode(r)?),
-            4 => Inventory::CompactBlock(Decodable::consensus_decode(r)?),
-            5 => Inventory::WTx(Decodable::consensus_decode(r)?),
-            0x40000001 => Inventory::WitnessTransaction(Decodable::consensus_decode(r)?),
-            0x40000002 => Inventory::WitnessBlock(Decodable::consensus_decode(r)?),
-            tp => Inventory::Unknown { inv_type: tp, hash: Decodable::consensus_decode(r)? },
+            0 => Self::Error(Decodable::consensus_decode(r)?),
+            1 => Self::Transaction(Decodable::consensus_decode(r)?),
+            2 => Self::Block(Decodable::consensus_decode(r)?),
+            4 => Self::CompactBlock(Decodable::consensus_decode(r)?),
+            5 => Self::WTx(Decodable::consensus_decode(r)?),
+            0x4000_0001 => Self::WitnessTransaction(Decodable::consensus_decode(r)?),
+            0x4000_0002 => Self::WitnessBlock(Decodable::consensus_decode(r)?),
+            tp => Self::Unknown { inv_type: tp, hash: Decodable::consensus_decode(r)? },
         })
     }
 }
@@ -102,7 +106,7 @@ impl Decodable for Inventory {
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct GetBlocksMessage {
     /// The protocol version
-    pub version: u32,
+    pub version: ProtocolVersion,
     /// Locator hashes --- ordered newest to oldest. The remote peer will
     /// reply with its longest known chain, starting from a locator hash
     /// if possible and block 1 otherwise.
@@ -115,7 +119,7 @@ pub struct GetBlocksMessage {
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct GetHeadersMessage {
     /// The protocol version
-    pub version: u32,
+    pub version: ProtocolVersion,
     /// Locator hashes --- ordered newest to oldest. The remote peer will
     /// reply with its longest known chain, starting from a locator hash
     /// if possible and block 1 otherwise.
@@ -124,30 +128,54 @@ pub struct GetHeadersMessage {
     pub stop_hash: BlockHash,
 }
 
-impl GetBlocksMessage {
-    /// Construct a new `getblocks` message
-    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetBlocksMessage {
-        GetBlocksMessage { version: p2p::PROTOCOL_VERSION, locator_hashes, stop_hash }
+impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash);
+
+impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetHeadersMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            version: u.arbitrary()?,
+            locator_hashes: Vec::<BlockHash>::arbitrary(u)?,
+            stop_hash: u.arbitrary()?,
+        })
     }
 }
 
-impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash);
-
-impl GetHeadersMessage {
-    /// Construct a new `getheaders` message
-    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetHeadersMessage {
-        GetHeadersMessage { version: p2p::PROTOCOL_VERSION, locator_hashes, stop_hash }
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetBlocksMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            version: u.arbitrary()?,
+            locator_hashes: Vec::<BlockHash>::arbitrary(u)?,
+            stop_hash: u.arbitrary()?,
+        })
     }
 }
 
-impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash);
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Inventory {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=7)? {
+            0 => Ok(Self::Error(u.arbitrary()?)),
+            1 => Ok(Self::Transaction(u.arbitrary()?)),
+            2 => Ok(Self::Block(u.arbitrary()?)),
+            3 => Ok(Self::CompactBlock(u.arbitrary()?)),
+            4 => Ok(Self::WTx(u.arbitrary()?)),
+            5 => Ok(Self::WitnessTransaction(u.arbitrary()?)),
+            6 => Ok(Self::WitnessBlock(u.arbitrary()?)),
+            _ => Ok(Self::Unknown { inv_type: u.arbitrary()?, hash: u.arbitrary()? }),
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
+    use bitcoin::consensus::encode::{deserialize, serialize};
     use hex_lit::hex;
 
     use super::*;
-    use crate::consensus::encode::{deserialize, serialize};
 
     #[test]
     fn getblocks_message() {
@@ -157,7 +185,7 @@ mod tests {
         let decode: Result<GetBlocksMessage, _> = deserialize(&from_sat);
         assert!(decode.is_ok());
         let real_decode = decode.unwrap();
-        assert_eq!(real_decode.version, 70002);
+        assert_eq!(real_decode.version.0, 70002);
         assert_eq!(real_decode.locator_hashes.len(), 1);
         assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
         assert_eq!(real_decode.stop_hash, BlockHash::GENESIS_PREVIOUS_BLOCK_HASH);
@@ -173,7 +201,7 @@ mod tests {
         let decode: Result<GetHeadersMessage, _> = deserialize(&from_sat);
         assert!(decode.is_ok());
         let real_decode = decode.unwrap();
-        assert_eq!(real_decode.version, 70002);
+        assert_eq!(real_decode.version.0, 70002);
         assert_eq!(real_decode.locator_hashes.len(), 1);
         assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
         assert_eq!(real_decode.stop_hash, BlockHash::GENESIS_PREVIOUS_BLOCK_HASH);
diff --git a/bitcoin/src/p2p/message_bloom.rs b/p2p/src/message_bloom.rs
similarity index 51%
rename from bitcoin/src/p2p/message_bloom.rs
rename to p2p/src/message_bloom.rs
index 2a75f9a64d..c09ddce101 100644
--- a/bitcoin/src/p2p/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -2,12 +2,16 @@
 
 //! Bitcoin Connection Bloom filtering network messages.
 //!
-//! This module describes BIP37 Connection Bloom filtering network messages.
+//! This module describes BIP-0037 Connection Bloom filtering network messages.
 
+use alloc::vec::Vec;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::{encode, Decodable, Encodable, ReadExt};
 use io::{BufRead, Write};
 
-use crate::consensus::{self, encode, Decodable, Encodable, ReadExt};
-use crate::internal_macros::impl_consensus_encoding;
+use crate::consensus::impl_consensus_encoding;
 
 /// `filterload` message sets the current bloom filter
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -38,9 +42,9 @@ pub enum BloomFlags {
 impl Encodable for BloomFlags {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         w.write_all(&[match self {
-            BloomFlags::None => 0,
-            BloomFlags::All => 1,
-            BloomFlags::PubkeyOnly => 2,
+            Self::None => 0,
+            Self::All => 1,
+            Self::PubkeyOnly => 2,
         }])?;
         Ok(1)
     }
@@ -49,10 +53,10 @@ impl Encodable for BloomFlags {
 impl Decodable for BloomFlags {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         Ok(match r.read_u8()? {
-            0 => BloomFlags::None,
-            1 => BloomFlags::All,
-            2 => BloomFlags::PubkeyOnly,
-            _ => return Err(consensus::parse_failed_error("unknown bloom flag")),
+            0 => Self::None,
+            1 => Self::All,
+            2 => Self::PubkeyOnly,
+            _ => return Err(crate::consensus::parse_failed_error("unknown bloom flag")),
         })
     }
 }
@@ -65,3 +69,33 @@ pub struct FilterAdd {
 }
 
 impl_consensus_encoding!(FilterAdd, data);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BloomFlags {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=2)? {
+            0 => Ok(Self::None),
+            1 => Ok(Self::All),
+            _ => Ok(Self::PubkeyOnly),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FilterAdd {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { data: Vec::<u8>::arbitrary(u)? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FilterLoad {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter: Vec::<u8>::arbitrary(u)?,
+            hash_funcs: u.arbitrary()?,
+            tweak: u.arbitrary()?,
+            flags: u.arbitrary()?,
+        })
+    }
+}
diff --git a/bitcoin/src/p2p/message_compact_blocks.rs b/p2p/src/message_compact_blocks.rs
similarity index 58%
rename from bitcoin/src/p2p/message_compact_blocks.rs
rename to p2p/src/message_compact_blocks.rs
index 333a8c243f..685696ff3d 100644
--- a/bitcoin/src/p2p/message_compact_blocks.rs
+++ b/p2p/src/message_compact_blocks.rs
@@ -1,10 +1,13 @@
 // SPDX-License-Identifier: CC0-1.0
 
 //!
-//! BIP152  Compact Blocks network messages
+//! BIP-0152  Compact Blocks network messages
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 
 use crate::bip152;
-use crate::internal_macros::impl_consensus_encoding;
+use crate::consensus::impl_consensus_encoding;
 
 /// sendcmpct message
 #[derive(PartialEq, Eq, Clone, Debug, Copy, PartialOrd, Ord, Hash)]
@@ -44,3 +47,31 @@ pub struct BlockTxn {
     pub transactions: bip152::BlockTransactions,
 }
 impl_consensus_encoding!(BlockTxn, transactions);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for SendCmpct {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { send_compact: u.arbitrary()?, version: u.arbitrary()? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for CmpctBlock {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { compact_block: u.arbitrary()? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetBlockTxn {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { txs_request: u.arbitrary()? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BlockTxn {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { transactions: u.arbitrary()? })
+    }
+}
diff --git a/p2p/src/message_filter.rs b/p2p/src/message_filter.rs
new file mode 100644
index 0000000000..bed5ea337e
--- /dev/null
+++ b/p2p/src/message_filter.rs
@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin Client Side Block Filtering network messages.
+//!
+//! This module describes BIP-0157 Client Side Block Filtering network messages.
+
+use alloc::vec::Vec;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::{sha256d, HashEngine};
+use primitives::BlockHash;
+use units::BlockHeight;
+
+use crate::consensus::impl_consensus_encoding;
+
+hashes::hash_newtype! {
+    /// Filter hash, as defined in BIP-0157.
+    pub struct FilterHash(pub sha256d::Hash);
+    /// Filter header, as defined in BIP-0157.
+    pub struct FilterHeader(pub sha256d::Hash);
+}
+
+hashes::impl_hex_for_newtype!(FilterHash, FilterHeader);
+
+impl FilterHash {
+    /// Computes the filter header from a filter hash and previous filter header.
+    pub fn filter_header(&self, previous_filter_header: FilterHeader) -> FilterHeader {
+        let mut engine = sha256d::Hash::engine();
+        engine.input(self.as_ref());
+        engine.input(previous_filter_header.as_ref());
+        FilterHeader(sha256d::Hash::from_engine(engine))
+    }
+}
+
+#[rustfmt::skip]
+macro_rules! impl_hashencode {
+    ($hashtype:ident) => {
+        impl bitcoin::consensus::Encodable for $hashtype {
+            fn consensus_encode<W: bitcoin::io::Write + ?Sized>(&self, w: &mut W) -> core::result::Result<usize, bitcoin::io::Error> {
+                self.as_byte_array().consensus_encode(w)
+            }
+        }
+
+        impl bitcoin::consensus::Decodable for $hashtype {
+            fn consensus_decode<R: bitcoin::io::BufRead + ?Sized>(r: &mut R) -> core::result::Result<Self, bitcoin::consensus::encode::Error> {
+                Ok(Self::from_byte_array(<<$hashtype as hashes::Hash>::Bytes>::consensus_decode(r)?))
+            }
+        }
+    };
+}
+
+impl_hashencode!(FilterHash);
+impl_hashencode!(FilterHeader);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FilterHash {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::from_byte_array(u.arbitrary()?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FilterHeader {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::from_byte_array(u.arbitrary()?))
+    }
+}
+
+/// getcfilters message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct GetCFilters {
+    /// Filter type for which headers are requested
+    pub filter_type: u8,
+    /// The height of the first block in the requested range
+    pub start_height: BlockHeight,
+    /// The hash of the last block in the requested range
+    pub stop_hash: BlockHash,
+}
+impl_consensus_encoding!(GetCFilters, filter_type, start_height, stop_hash);
+
+/// cfilter message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CFilter {
+    /// Byte identifying the type of filter being returned
+    pub filter_type: u8,
+    /// Block hash of the Bitcoin block for which the filter is being returned
+    pub block_hash: BlockHash,
+    /// The serialized compact filter for this block
+    pub filter: Vec<u8>,
+}
+impl_consensus_encoding!(CFilter, filter_type, block_hash, filter);
+
+/// getcfheaders message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct GetCFHeaders {
+    /// Byte identifying the type of filter being returned
+    pub filter_type: u8,
+    /// The height of the first block in the requested range
+    pub start_height: BlockHeight,
+    /// The hash of the last block in the requested range
+    pub stop_hash: BlockHash,
+}
+impl_consensus_encoding!(GetCFHeaders, filter_type, start_height, stop_hash);
+
+/// cfheaders message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CFHeaders {
+    /// Filter type for which headers are requested
+    pub filter_type: u8,
+    /// The hash of the last block in the requested range
+    pub stop_hash: BlockHash,
+    /// The filter header preceding the first block in the requested range
+    pub previous_filter_header: FilterHeader,
+    /// The filter hashes for each block in the requested range
+    pub filter_hashes: Vec<FilterHash>,
+}
+impl_consensus_encoding!(CFHeaders, filter_type, stop_hash, previous_filter_header, filter_hashes);
+
+/// getcfcheckpt message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct GetCFCheckpt {
+    /// Filter type for which headers are requested
+    pub filter_type: u8,
+    /// The hash of the last block in the requested range
+    pub stop_hash: BlockHash,
+}
+impl_consensus_encoding!(GetCFCheckpt, filter_type, stop_hash);
+
+/// cfcheckpt message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CFCheckpt {
+    /// Filter type for which headers are requested
+    pub filter_type: u8,
+    /// The hash of the last block in the requested range
+    pub stop_hash: BlockHash,
+    /// The filter headers at intervals of 1,000
+    pub filter_headers: Vec<FilterHeader>,
+}
+impl_consensus_encoding!(CFCheckpt, filter_type, stop_hash, filter_headers);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetCFilters {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter_type: u.arbitrary()?,
+            start_height: u.arbitrary()?,
+            stop_hash: u.arbitrary()?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for CFilter {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter_type: u.arbitrary()?,
+            block_hash: u.arbitrary()?,
+            filter: Vec::<u8>::arbitrary(u)?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetCFHeaders {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter_type: u.arbitrary()?,
+            start_height: u.arbitrary()?,
+            stop_hash: u.arbitrary()?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for CFHeaders {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter_type: u.arbitrary()?,
+            stop_hash: u.arbitrary()?,
+            previous_filter_header: u.arbitrary()?,
+            filter_hashes: u.arbitrary()?,
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for GetCFCheckpt {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self { filter_type: u.arbitrary()?, stop_hash: u.arbitrary()? })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for CFCheckpt {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            filter_type: u.arbitrary()?,
+            stop_hash: u.arbitrary()?,
+            filter_headers: Vec::<FilterHeader>::arbitrary(u)?,
+        })
+    }
+}
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
new file mode 100644
index 0000000000..7ff700f19a
--- /dev/null
+++ b/p2p/src/message_network.rs
@@ -0,0 +1,543 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network-related network messages.
+//!
+//! This module defines network messages which describe peers and their
+//! capabilities.
+
+use alloc::borrow::Cow;
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use bitcoin::consensus::{encode, Decodable, Encodable, ReadExt, WriteExt};
+use hashes::sha256d;
+use io::{BufRead, Write};
+
+use crate::address::Address;
+use crate::consensus::{impl_consensus_encoding, impl_vec_wrapper};
+use crate::{ProtocolVersion, ServiceFlags};
+
+// Some simple messages
+
+/// The `version` message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct VersionMessage {
+    /// The P2P network protocol version
+    pub version: ProtocolVersion,
+    /// A bitmask describing the services supported by this node
+    pub services: ServiceFlags,
+    /// The time at which the `version` message was sent
+    pub timestamp: i64,
+    /// The network address of the peer receiving the message
+    pub receiver: Address,
+    /// The network address of the peer sending the message
+    pub sender: Address,
+    /// A random nonce used to detect loops in the network
+    ///
+    /// The nonce can be used to detect situations when a node accidentally
+    /// connects to itself. Set it to a random value and, in case of incoming
+    /// connections, compare the value - same values mean self-connection.
+    ///
+    /// If your application uses P2P to only fetch the data and doesn't listen
+    /// you may just set it to 0.
+    pub nonce: u64,
+    /// A string describing the peer's software
+    pub user_agent: UserAgent,
+    /// The height of the maximum-work blockchain that the peer is aware of
+    pub start_height: i32,
+    /// Whether the receiving peer should relay messages to the sender; used
+    /// if the sender is bandwidth-limited and would like to support bloom
+    /// filtering. Defaults to false.
+    pub relay: bool,
+}
+
+impl VersionMessage {
+    /// Constructs a new `version` message with `relay` set to false
+    pub fn new(
+        version: ProtocolVersion,
+        services: ServiceFlags,
+        timestamp: i64,
+        receiver: Address,
+        sender: Address,
+        nonce: u64,
+        user_agent: UserAgent,
+        start_height: i32,
+    ) -> Self {
+        Self {
+            version,
+            services,
+            timestamp,
+            receiver,
+            sender,
+            nonce,
+            user_agent,
+            start_height,
+            relay: false,
+        }
+    }
+}
+
+impl_consensus_encoding!(
+    VersionMessage,
+    version,
+    services,
+    timestamp,
+    receiver,
+    sender,
+    nonce,
+    user_agent,
+    start_height,
+    relay
+);
+
+/// A bitcoin user agent defined by BIP-0014. The user agent is sent in the version message when a
+/// connection between two peers is established. It is intended to advertise client software in a
+/// well-defined format.
+///
+/// ref: <https://github.com/bitcoin/bips/blob/master/bip-0014.mediawiki>
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UserAgent {
+    user_agent: String,
+}
+
+impl_consensus_encoding!(UserAgent, user_agent);
+
+impl UserAgent {
+    const MAX_USER_AGENT_LEN: usize = 256;
+
+    fn panic_invalid_chars(agent_str: &str) {
+        assert!(
+            !agent_str.chars().any(|c| matches!(c, '/' | '(' | ')' | ':')),
+            "user agent configuration cannot contain: / ( ) :"
+        );
+    }
+
+    fn panic_max_len(agent_str: &str) {
+        assert!(
+            agent_str.chars().count() <= Self::MAX_USER_AGENT_LEN,
+            "user agent cannot exceed 256 characters."
+        );
+    }
+    /// Builds a new user agent from the lowest level client software. For example: `Satoshi` is
+    /// used by Bitcoin Core.
+    ///
+    /// # Panics
+    ///
+    /// If the client name contains one of: `/ ( ) :` or the user agent exceeds 256 characters.
+    pub fn new<S: AsRef<str>>(client_name: S, client_version: &UserAgentVersion) -> Self {
+        let parsed_name = client_name.as_ref();
+        Self::panic_invalid_chars(parsed_name);
+        let agent = format!("/{parsed_name}:{client_version}/");
+        Self::panic_max_len(&agent);
+        Self { user_agent: agent }
+    }
+
+    /// Builds a user agent, ignoring BIP-0014 recommendations.
+    pub fn from_nonstandard<S: ToString>(agent: &S) -> Self {
+        Self { user_agent: agent.to_string() }
+    }
+
+    /// Adds a client to the user agent string. Examples may include the name of a wallet software.
+    ///
+    /// # Panics
+    ///
+    /// If the client name contains one of: `/ ( ) :` or the user agent exceeds 256 characters.
+    #[must_use]
+    pub fn add_client<S: AsRef<str>>(
+        mut self,
+        client_name: S,
+        client_version: &UserAgentVersion,
+    ) -> Self {
+        let parsed_name = client_name.as_ref();
+        Self::panic_invalid_chars(parsed_name);
+        let agent = format!("{parsed_name}:{client_version}/");
+        self.user_agent.push_str(&agent);
+        Self::panic_max_len(&self.user_agent);
+        self
+    }
+}
+
+impl std::fmt::Display for UserAgent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { self.user_agent.fmt(f) }
+}
+
+impl From<UserAgent> for String {
+    fn from(agent: UserAgent) -> Self { agent.user_agent }
+}
+
+/// A software version field for inclusion in a user agent specified by BIP-0014.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UserAgentVersion {
+    version: ClientSoftwareVersion,
+    comments: Option<String>,
+}
+
+impl UserAgentVersion {
+    /// Creates a user agent client version associated with a name.
+    pub const fn new(software_version: ClientSoftwareVersion) -> Self {
+        Self { version: software_version, comments: None }
+    }
+
+    /// Adds a comment to the version. Typical comments describe the operating system or platform
+    /// that is executing the program, however these may be any comment.
+    ///
+    /// An example may include `Android`.
+    ///
+    /// # Panics
+    ///
+    /// If the client name contains one of: `/ ( ) :`
+    #[must_use]
+    pub fn push_comment<S: AsRef<str>>(mut self, comment: S) -> Self {
+        let parsed_comment = comment.as_ref();
+        UserAgent::panic_invalid_chars(parsed_comment);
+        match self.comments {
+            Some(mut comment) => {
+                let semi_colon_delimiter = format!("; {parsed_comment}");
+                comment.push_str(&semi_colon_delimiter);
+                self.comments = Some(comment);
+            }
+            None => self.comments = Some(parsed_comment.to_string()),
+        }
+        self
+    }
+}
+
+impl std::fmt::Display for UserAgentVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut software_version = self.version.to_string();
+        if let Some(comments) = &self.comments {
+            let comments = format!("({comments})");
+            software_version.push_str(&comments);
+        }
+        software_version.fmt(f)
+    }
+}
+
+/// Software tagged by version number or date for inclusion in a user agent field.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ClientSoftwareVersion {
+    /// Semantic versioning release.
+    SemVer {
+        /// X.0.0
+        major: u16,
+        /// 0.X.0
+        minor: u16,
+        /// 0.0.X
+        revision: u16,
+    },
+    /// The release date of a software.
+    Date {
+        /// Year, represented as 4 digits
+        yyyy: u16,
+        /// The month
+        mm: u8,
+        /// The day
+        dd: u8,
+    },
+}
+
+impl std::fmt::Display for ClientSoftwareVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Date { yyyy, mm, dd } => format!("{yyyy}{mm:02}{dd:02}").fmt(f),
+            Self::SemVer { major, minor, revision } => format!("{major}.{minor}.{revision}").fmt(f),
+        }
+    }
+}
+
+/// message rejection reason as a code
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+pub enum RejectReason {
+    /// malformed message
+    Malformed = 0x01,
+    /// invalid message
+    Invalid = 0x10,
+    /// obsolete message
+    Obsolete = 0x11,
+    /// duplicate message
+    Duplicate = 0x12,
+    /// nonstandard transaction
+    NonStandard = 0x40,
+    /// an output is below dust limit
+    Dust = 0x41,
+    /// insufficient fee
+    Fee = 0x42,
+    /// checkpoint
+    Checkpoint = 0x43,
+}
+
+impl Encodable for RejectReason {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        w.write_all(&[*self as u8])?;
+        Ok(1)
+    }
+}
+
+impl Decodable for RejectReason {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(match r.read_u8()? {
+            0x01 => Self::Malformed,
+            0x10 => Self::Invalid,
+            0x11 => Self::Obsolete,
+            0x12 => Self::Duplicate,
+            0x40 => Self::NonStandard,
+            0x41 => Self::Dust,
+            0x42 => Self::Fee,
+            0x43 => Self::Checkpoint,
+            _ => return Err(crate::consensus::parse_failed_error("unknown reject code")),
+        })
+    }
+}
+
+/// Reject message might be sent by peers rejecting one of our messages
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct Reject {
+    /// message type rejected
+    pub message: Cow<'static, str>,
+    /// reason of rejection as code
+    pub ccode: RejectReason,
+    /// reason of rejection
+    pub reason: Cow<'static, str>,
+    /// reference to rejected item
+    pub hash: sha256d::Hash,
+}
+
+impl_consensus_encoding!(Reject, message, ccode, reason, hash);
+
+/// A deprecated message type that was used to notify users of system changes. Due to a number of
+/// vulnerabilities, alerts are no longer used. A final alert was sent as of Bitcoin Core 0.14.0,
+/// and is sent to any node that is advertising a potentially vulnerable protocol version.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Alert(Vec<u8>);
+
+impl Alert {
+    const FINAL_ALERT: [u8; 96] = [
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127,
+        254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255,
+        255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121,
+        32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97,
+        100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0,
+    ];
+
+    /// Builds the final alert to send to a potentially vulnerable peer.
+    pub fn final_alert() -> Self { Self(Self::FINAL_ALERT.into()) }
+
+    /// The final alert advertised by Bitcoin Core. This alert is sent if the advertised protocol
+    /// version is vulnerable to the alert-system vulnerabilities.
+    pub fn is_final_alert(&self) -> bool { self.0.eq(&Self::FINAL_ALERT) }
+}
+
+impl_vec_wrapper!(Alert, Vec<u8>);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for ClientSoftwareVersion {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match bool::arbitrary(u)? {
+            true => Ok(Self::Date { yyyy: u.arbitrary()?, mm: u.arbitrary()?, dd: u.arbitrary()? }),
+            false => Ok(Self::SemVer {
+                major: u.arbitrary()?,
+                minor: u.arbitrary()?,
+                revision: u.arbitrary()?,
+            }),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for UserAgentVersion {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::new(u.arbitrary()?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for UserAgent {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::new(u.arbitrary::<String>()?, &u.arbitrary()?))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for VersionMessage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::new(
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+            u.arbitrary()?,
+        ))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for RejectReason {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match u.int_in_range(0..=7)? {
+            0 => Ok(Self::Malformed),
+            1 => Ok(Self::Invalid),
+            2 => Ok(Self::Obsolete),
+            3 => Ok(Self::Duplicate),
+            4 => Ok(Self::NonStandard),
+            5 => Ok(Self::Dust),
+            6 => Ok(Self::Fee),
+            _ => Ok(Self::Checkpoint),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Reject {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self {
+            message: u.arbitrary::<String>()?.into(),
+            ccode: u.arbitrary()?,
+            reason: u.arbitrary::<String>()?.into(),
+            hash: sha256d::Hash::from_byte_array(u.arbitrary()?),
+        })
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Alert {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self(Vec::<u8>::arbitrary(u)?))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::string::ToString;
+
+    use bitcoin::consensus::encode::{deserialize, serialize};
+    use hex_lit::hex;
+
+    use super::*;
+
+    #[test]
+    fn version_message_test() {
+        // This message is from my satoshi node, morning of May 27 2014
+        let from_sat = hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001");
+
+        let decode: Result<VersionMessage, _> = deserialize(&from_sat);
+        assert!(decode.is_ok());
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.version.0, 70002);
+        assert_eq!(real_decode.services, ServiceFlags::NETWORK);
+        assert_eq!(real_decode.timestamp, 1_401_217_254);
+        // address decodes should be covered by Address tests
+        assert_eq!(real_decode.nonce, 16_735_069_437_859_780_935);
+        assert_eq!(
+            real_decode.user_agent,
+            UserAgent::new(
+                "Satoshi",
+                &UserAgentVersion::new(ClientSoftwareVersion::SemVer {
+                    major: 0,
+                    minor: 9,
+                    revision: 99
+                })
+            )
+        );
+        assert_eq!(real_decode.start_height, 302_892);
+        assert!(real_decode.relay);
+
+        assert_eq!(serialize(&real_decode), from_sat);
+    }
+
+    #[test]
+    fn reject_message_test() {
+        let reject_tx_conflict = hex!("027478121474786e2d6d656d706f6f6c2d636f6e666c69637405df54d3860b3c41806a3546ab48279300affacf4b88591b229141dcf2f47004");
+        let reject_tx_nonfinal = hex!("02747840096e6f6e2d66696e616c259bbe6c83db8bbdfca7ca303b19413dc245d9f2371b344ede5f8b1339a5460b");
+
+        let decode_result_conflict: Result<Reject, _> = deserialize(&reject_tx_conflict);
+        let decode_result_nonfinal: Result<Reject, _> = deserialize(&reject_tx_nonfinal);
+
+        assert!(decode_result_conflict.is_ok());
+        assert!(decode_result_nonfinal.is_ok());
+
+        let conflict = decode_result_conflict.unwrap();
+        assert_eq!("tx", conflict.message);
+        assert_eq!(RejectReason::Duplicate, conflict.ccode);
+        assert_eq!("txn-mempool-conflict", conflict.reason);
+        assert_eq!(
+            "0470f4f2dc4191221b59884bcffaaf00932748ab46356a80413c0b86d354df05"
+                .parse::<sha256d::Hash>()
+                .unwrap(),
+            conflict.hash
+        );
+
+        let nonfinal = decode_result_nonfinal.unwrap();
+        assert_eq!("tx", nonfinal.message);
+        assert_eq!(RejectReason::NonStandard, nonfinal.ccode);
+        assert_eq!("non-final", nonfinal.reason);
+        assert_eq!(
+            "0b46a539138b5fde4e341b37f2d945c23d41193b30caa7fcbd8bdb836cbe9b25"
+                .parse::<sha256d::Hash>()
+                .unwrap(),
+            nonfinal.hash
+        );
+
+        assert_eq!(serialize(&conflict), reject_tx_conflict);
+        assert_eq!(serialize(&nonfinal), reject_tx_nonfinal);
+    }
+
+    #[test]
+    fn alert_message_test() {
+        let alert_hex = hex!("60010000000000000000000000ffffff7f00000000ffffff7ffeffff7f01ffffff7f00000000ffffff7f00ffffff7f002f555247454e543a20416c657274206b657920636f6d70726f6d697365642c207570677261646520726571756972656400");
+        let alert: Alert = deserialize(&alert_hex).unwrap();
+        assert!(alert.is_final_alert());
+    }
+
+    #[test]
+    fn test_user_agent() {
+        let client_name = "Satoshi";
+        let client_version = UserAgentVersion::new(ClientSoftwareVersion::SemVer {
+            major: 5,
+            minor: 12,
+            revision: 0,
+        });
+        let user_agent = UserAgent::new(client_name, &client_version);
+        assert_eq!("/Satoshi:5.12.0/", user_agent.to_string());
+        let wallet_name = "bitcoin-qt";
+        let wallet_version = UserAgentVersion::new(ClientSoftwareVersion::SemVer {
+            major: 0,
+            minor: 8,
+            revision: 0,
+        });
+        let user_agent = user_agent.add_client(wallet_name, &wallet_version);
+        assert_eq!("/Satoshi:5.12.0/bitcoin-qt:0.8.0/", user_agent.to_string());
+        let client_name = "BitcoinJ";
+        let client_version =
+            UserAgentVersion::new(ClientSoftwareVersion::Date { yyyy: 2011, mm: 1, dd: 28 });
+        let user_agent = UserAgent::new(client_name, &client_version);
+        assert_eq!("/BitcoinJ:20110128/", user_agent.to_string());
+        let wallet_name = "Electrum";
+        let wallet_version = UserAgentVersion::new(ClientSoftwareVersion::SemVer {
+            major: 0,
+            minor: 9,
+            revision: 0,
+        });
+        let wallet_version = wallet_version.push_comment("Ubuntu");
+        let wallet_version = wallet_version.push_comment("24");
+        let user_agent = user_agent.add_client(wallet_name, &wallet_version);
+        assert_eq!("/BitcoinJ:20110128/Electrum:0.9.0(Ubuntu; 24)/", user_agent.to_string());
+    }
+
+    #[test]
+    #[should_panic(expected = "user agent configuration cannot contain: / ( ) :")]
+    fn test_incorrect_user_agent() {
+        let client_name = "Satoshi/";
+        let client_version = UserAgentVersion::new(ClientSoftwareVersion::SemVer {
+            major: 5,
+            minor: 12,
+            revision: 0,
+        });
+        UserAgent::new(client_name, &client_version);
+    }
+}
diff --git a/p2p/src/network_ext.rs b/p2p/src/network_ext.rs
new file mode 100644
index 0000000000..b30e90bbd4
--- /dev/null
+++ b/p2p/src/network_ext.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! This module implements an extension trait for [`Network`]
+//! with getter methods for the default P2P port and default
+//! network [`Magic`] bytes.
+
+use bitcoin::{Network, TestnetVersion};
+
+use crate::Magic;
+
+/// Trait that extends [`Network`] by adding getter methods for the default P2P ports and [`Magic`] bytes.
+pub trait NetworkExt {
+    /// The default P2P port for a given [`Network`].
+    fn default_p2p_port(self) -> u16;
+
+    /// The default network [`Magic`] for a given [`Network`].
+    fn default_network_magic(self) -> Magic;
+}
+
+impl NetworkExt for Network {
+    /// The default P2P port for a given [`Network`].
+    ///
+    /// Note: All [`TestnetVersion`] variants >4 are treated as [`TestnetVersion::V4`].
+    /// This function will be updated as new test networks are defined.
+    fn default_p2p_port(self) -> u16 {
+        match &self {
+            Self::Bitcoin => 8333,
+            Self::Signet => 38333,
+            Self::Testnet(TestnetVersion::V3) => 18333,
+            Self::Testnet(TestnetVersion::V4) => 48333,
+            Self::Testnet(_) => 48333,
+            Self::Regtest => 18444,
+        }
+    }
+
+    /// The default network [`Magic`] for a given [`Network`].
+    ///
+    /// Note: All [`TestnetVersion`] variants >4 are treated as [`TestnetVersion::V4`].
+    /// This function will be updated as new test networks are defined.
+    fn default_network_magic(self) -> Magic {
+        match &self {
+            Self::Bitcoin => Magic::BITCOIN,
+            Self::Signet => Magic::SIGNET,
+            Self::Testnet(TestnetVersion::V3) => Magic::TESTNET3,
+            Self::Testnet(TestnetVersion::V4) => Magic::TESTNET4,
+            Self::Testnet(_) => Magic::TESTNET4,
+            Self::Regtest => Magic::REGTEST,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::vec;
+
+    use super::*;
+
+    #[test]
+    fn default_p2p_port() {
+        let networks = [
+            Network::Bitcoin,
+            Network::Signet,
+            Network::Testnet(TestnetVersion::V3),
+            Network::Testnet(TestnetVersion::V4),
+            Network::Regtest,
+        ];
+
+        let p2p_ports = vec![8333, 38333, 18333, 48333, 18444];
+
+        for (network, p2p_port) in networks.iter().zip(p2p_ports) {
+            assert_eq!(network.default_p2p_port(), p2p_port);
+        }
+    }
+
+    #[test]
+    fn default_network_magic() {
+        let networks = [
+            Network::Bitcoin,
+            Network::Signet,
+            Network::Testnet(TestnetVersion::V3),
+            Network::Testnet(TestnetVersion::V4),
+            Network::Regtest,
+        ];
+
+        let network_magics =
+            vec![Magic::BITCOIN, Magic::SIGNET, Magic::TESTNET3, Magic::TESTNET4, Magic::REGTEST];
+
+        for (network, network_magic) in networks.iter().zip(network_magics) {
+            assert_eq!(network.default_network_magic(), network_magic);
+        }
+    }
+}
diff --git a/primitives/CHANGELOG.md b/primitives/CHANGELOG.md
index 762bd9c15f..5184c49e16 100644
--- a/primitives/CHANGELOG.md
+++ b/primitives/CHANGELOG.md
@@ -1,3 +1,70 @@
+# 1.0.0 - 2025-10-18
+
+This changelog is a rolling description of everything that will eventually end up in `v1.0`.
+
+There are a bunch of changes in this stable release, of note script
+tagging and the consensus encoding re-write.
+
+- Introduce script tagging [#4907](https://github.com/rust-bitcoin/rust-bitcoin/pull/4907)
+- Introduce pull encoding and use it for blockhash computation [#4912](https://github.com/rust-bitcoin/rust-bitcoin/pull/4912)
+- Implement `Encodable` for `&Script<T>` [#4978](https://github.com/rust-bitcoin/rust-bitcoin/pull/4978)
+
+And also we did:
+
+- Remove `hashes` from the public API [#4935](https://github.com/rust-bitcoin/rust-bitcoin/pull/4935)
+- Bump MSRV from 1.63.0 to 1.74.0 for all crates in the repo [#4926](https://github.com/rust-bitcoin/rust-bitcoin/pull/4926)
+- Rename `units::parse` to `parse_int` [#4886](https://github.com/rust-bitcoin/rust-bitcoin/pull/4886)
+- Introduce `Ntxid` [#4839](https://github.com/rust-bitcoin/rust-bitcoin/pull/4839)
+- Remove `serde` impls from some primitive types [#4806](https://github.com/rust-bitcoin/rust-bitcoin/pull/48064806)
+- Pluralize transaction fields [#4788](https://github.com/rust-bitcoin/rust-bitcoin/pull/4788)
+- Use `CompactSize` instead of `VarInt` [#4790](https://github.com/rust-bitcoin/rust-bitcoin/pull/4790)
+- Do not derive `Default` on `CompactTarget` [#4561](https://github.com/rust-bitcoin/rust-bitcoin/pull/4561)
+- Deserialize witness from a list of hex strings [#4366](https://github.com/rust-bitcoin/rust-bitcoin/pull/4366)
+- Implement `FromIterator` for `Witness` [#4365](https://github.com/rust-bitcoin/rust-bitcoin/pull/4365)
+- Return `ControlBlock` from `Witness::taproot_control_block` [#4281](https://github.com/rust-bitcoin/rust-bitcoin/pull/4281)
+- Witness api improvements and test cleanups [#4279](https://github.com/rust-bitcoin/rust-bitcoin/pull/4279)
+- Implement `Display` for `Header` [#4269](https://github.com/rust-bitcoin/rust-bitcoin/pull/4269)
+- Make `hex` optional [#4262](https://github.com/rust-bitcoin/rust-bitcoin/pull/4262)
+- Clean up Witness API [#4186](https://github.com/rust-bitcoin/rust-bitcoin/pull/4186)
+- Move `taproot` back to `bitcoin` crate [#4129](https://github.com/rust-bitcoin/rust-bitcoin/pull/4129)
+- Make `transaction::Version` field private [#4099](https://github.com/rust-bitcoin/rust-bitcoin/pull/4099)
+- Hide error internals [#4091](https://github.com/rust-bitcoin/rust-bitcoin/pull/4091)
+- locktimes: Remove `PartialOrd` and `ArbitraryOrd` [#4065](https://github.com/rust-bitcoin/rust-bitcoin/pull/4065)
+- Make `Debug` representation of `Witness` to be slice of hex-encoded
+  bytes strings to improve readability [#4061](https://github.com/rust-bitcoin/rust-bitcoin/pull/4061)
+- Implement `Default` for `Script` [#4043](https://github.com/rust-bitcoin/rust-bitcoin/pull/4043)
+- Store `transaction::Version` as `u32` instead of `i32` [#4040](https://github.com/rust-bitcoin/rust-bitcoin/pull/4040)
+- Delete `TxOut::NULL` [#3978](https://github.com/rust-bitcoin/rust-bitcoin/pull/3978)
+- Reduce alloc requirements [#3711](https://github.com/rust-bitcoin/rust-bitcoin/pull/3711)
+- Remove `serde` from amounts [#3672](https://github.com/rust-bitcoin/rust-bitcoin/pull/3672)
+- Fix bug in witness stack getters [#3601](https://github.com/rust-bitcoin/rust-bitcoin/pull/3601)
+- Re-design and move `Block` to `primitives` [#3582](https://github.com/rust-bitcoin/rust-bitcoin/pull/3582)
+- Re-export `block::Header` as `BlockHeader` [#3562](https://github.com/rust-bitcoin/rust-bitcoin/pull/3562)
+- Favour `to_vec` over `to_bytes` [#3544](https://github.com/rust-bitcoin/rust-bitcoin/pull/3544)
+
+## Locktimes
+
+Lock times got a bit of work. A big win was:
+
+- Improve lock times - fix off-by-one bug #4468
+
+There was a bit of churn so we are not listing all the PRs. Better
+just to take a look at the new and improved API.
+
+If you persist locktimes using `serde` you may want to look at because
+we changed the format:
+
+- Modify locktime serde implementations #4511
+
+## Arbitrary
+
+- Add Arbitrary impl for BlockHash, TxMerkleNode, and Wtxid #4720
+- Add Arbitrary impl for relative::LockTime #4689
+
+## Mutation testing
+
+The whole crate is mutation tested using `cargo-mutants` - BOOM!
+
 # 0.101.0 - 2024-11-15
 
 This is the first "real" release of the `primitives` crate, as such it
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 7af43f83b7..0a87a32f44 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -1,9 +1,7 @@
 [package]
 name = "bitcoin-primitives"
-# Arbitrary high version number so as to not clash with the original
-# `bitcoin-primitives` crate that we replaced `v0.1.16-alpha`.
-version = "0.101.0"
-authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+version = "1.0.0-rc.1"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>", "Tobin C. Harding <me@tobin.cc>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
 description = "Primitive types used by the rust-bitcoin ecosystem"
@@ -11,159 +9,36 @@ categories = ["cryptography::cryptocurrencies", "no-std"]
 keywords = ["bitcoin", "types"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
 default = ["std", "hex"]
-std = ["alloc", "hashes/std", "hex?/std", "internals/std", "units/std", "arrayvec/std"]
-alloc = ["hashes/alloc", "hex?/alloc", "internals/alloc", "units/alloc"]
-serde = ["dep:serde", "hashes/serde", "hex?/serde", "internals/serde", "units/serde", "alloc", "hex"]
+std = ["alloc", "hashes/std", "hex-stable?/std", "hex-unstable?/std", "internals/std", "units/std"]
+alloc = ["hashes/alloc", "hex-stable?/alloc", "hex-unstable?/alloc", "internals/alloc", "units/alloc"]
+serde = ["dep:serde", "hashes/serde", "internals/serde", "units/serde", "alloc", "hex"]
 arbitrary = ["dep:arbitrary", "units/arbitrary"]
-hex = ["dep:hex", "hashes/hex", "internals/hex"]
+hex = ["dep:hex-stable", "dep:hex-unstable", "hashes/hex", "internals/hex"]
 
 [dependencies]
-hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = false }
-internals = { package = "bitcoin-internals", path = "../internals" }
-units = { package = "bitcoin-units", path = "../units", default-features = false }
-arrayvec = { version = "0.7", default-features = false }
+encoding = { package = "bitcoin-consensus-encoding", path = "../consensus_encoding", version = "=1.0.0-rc.2", default-features = false }
+hashes = { package = "bitcoin_hashes", path = "../hashes", version = "0.18.0", default-features = false }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.1" }
+units = { package = "bitcoin-units", path = "../units", version = "=1.0.0-rc.3", default-features = false, features = [ "encoding" ] }
 
-arbitrary = { version = "1.4", optional = true }
-hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
-serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"], optional = true }
+arbitrary = { version = "1.4.1", optional = true }
+hex-stable = { package = "hex-conservative", version = "1.0.0", default-features = false, optional = true }
+hex-unstable = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
+serde = { version = "1.0.195", default-features = false, features = ["derive", "alloc"], optional = true }
 
 [dev-dependencies]
-serde_json = "1.0.0"
+serde_json = "1.0.68"
 bincode = "1.3.1"
+hex_lit = "0.1.1"
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints.clippy]
-# Exclude lints we don't think are valuable.
-needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
-manual_range_contains = "allow" # More readable than clippy's format.
-# Exhaustive list of pedantic clippy lints
-assigning_clones = "warn"
-bool_to_int_with_if = "warn"
-borrow_as_ptr = "warn"
-case_sensitive_file_extension_comparisons = "warn"
-cast_lossless = "warn"
-cast_possible_truncation = "allow" # All casts should include a code comment (except test code).
-cast_possible_wrap = "allow" # Same as above re code comment.
-cast_precision_loss = "warn"
-cast_ptr_alignment = "warn"
-cast_sign_loss = "allow" # All casts should include a code comment (except in test code).
-checked_conversions = "warn"
-cloned_instead_of_copied = "warn"
-copy_iterator = "warn"
-default_trait_access = "warn"
-doc_link_with_quotes = "warn"
-doc_markdown = "warn"
-empty_enum = "warn"
-enum_glob_use = "warn"
-expl_impl_clone_on_copy = "warn"
-explicit_deref_methods = "warn"
-explicit_into_iter_loop = "warn"
-explicit_iter_loop = "warn"
-filter_map_next = "warn"
-flat_map_option = "warn"
-float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
-fn_params_excessive_bools = "warn"
-from_iter_instead_of_collect = "warn"
-if_not_else = "warn"
-ignored_unit_patterns = "warn"
-implicit_clone = "warn"
-implicit_hasher = "warn"
-inconsistent_struct_constructor = "warn"
-index_refutable_slice = "warn"
-inefficient_to_string = "warn"
-inline_always = "warn"
-into_iter_without_iter = "warn"
-invalid_upcast_comparisons = "warn"
-items_after_statements = "warn"
-iter_filter_is_ok = "warn"
-iter_filter_is_some = "warn"
-iter_not_returning_iterator = "warn"
-iter_without_into_iter = "warn"
-large_digit_groups = "warn"
-large_futures = "warn"
-large_stack_arrays = "warn"
-large_types_passed_by_value = "warn"
-linkedlist = "warn"
-macro_use_imports = "warn"
-manual_assert = "warn"
-manual_instant_elapsed = "warn"
-manual_is_power_of_two = "warn"
-manual_is_variant_and = "warn"
-manual_let_else = "warn"
-manual_ok_or = "warn"
-manual_string_new = "warn"
-many_single_char_names = "warn"
-map_unwrap_or = "warn"
-match_bool = "allow" # Adds extra indentation and LOC.
-match_on_vec_items = "warn"
-match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
-match_wild_err_arm = "warn"
-match_wildcard_for_single_variants = "warn"
-maybe_infinite_iter = "warn"
-mismatching_type_param_order = "warn"
-missing_errors_doc = "allow"      # TODO: Write errors section in docs.
-missing_fields_in_debug = "warn"
-missing_panics_doc = "warn"
-must_use_candidate = "allow" # Useful for audit but many false positives.
-mut_mut = "warn"
-naive_bytecount = "warn"
-needless_bitwise_bool = "warn"
-needless_continue = "warn"
-needless_for_each = "warn"
-needless_pass_by_value = "warn"
-needless_raw_string_hashes = "warn"
-no_effect_underscore_binding = "warn"
-no_mangle_with_rust_abi = "warn"
-option_as_ref_cloned = "warn"
-option_option = "warn"
-ptr_as_ptr = "warn"
-ptr_cast_constness = "warn"
-pub_underscore_fields = "warn"
-range_minus_one = "warn"
-range_plus_one = "warn"
-redundant_closure_for_method_calls = "warn"
-redundant_else = "warn"
-ref_as_ptr = "warn"
-ref_binding_to_reference = "warn"
-ref_option = "warn"
-ref_option_ref = "warn"
-return_self_not_must_use = "warn"
-same_functions_in_if_condition = "warn"
-semicolon_if_nothing_returned = "warn"
-should_panic_without_expect = "warn"
-similar_names = "allow" # Too many (subjectively) false positives.
-single_char_pattern = "warn"
-single_match_else = "warn"
-stable_sort_primitive = "warn"
-str_split_at_newline = "warn"
-string_add_assign = "warn"
-struct_excessive_bools = "warn"
-struct_field_names = "allow" # TODO: Triggers warning for `witness_elements`.
-too_many_lines = "warn"
-transmute_ptr_to_ptr = "warn"
-trivially_copy_pass_by_ref = "warn"
-unchecked_duration_subtraction = "warn"
-unicode_not_nfc = "warn"
-uninlined_format_args = "allow" # This is a subjective style choice.
-unnecessary_box_returns = "warn"
-unnecessary_join = "warn"
-unnecessary_literal_bound = "warn"
-unnecessary_wraps = "warn"
-unnested_or_patterns = "allow"  # TODO
-unreadable_literal = "warn"
-unsafe_derive_deserialize = "warn"
-unused_async = "warn"
-unused_self = "warn"
-used_underscore_binding = "warn"
-used_underscore_items = "warn"
-verbose_bit_mask = "warn"
-wildcard_imports = "warn"
-zero_sized_map_values = "warn"
+[lints]
+workspace = true
diff --git a/primitives/README.md b/primitives/README.md
index f6c32ef68c..979cc40df4 100644
--- a/primitives/README.md
+++ b/primitives/README.md
@@ -7,12 +7,3 @@ This crate provides primitive data types that are used throughout the
 
 Functions marked as unstable (e.g. `foo__unstable`) are not guaranteed to uphold semver compliance.
 They are primarily provided to support `rust-bitcoin`.
-
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
-
-## Licensing
-
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](../LICENSE).
-We use the [SPDX license list](https://spdx.org/licenses/) and [SPDX IDs](https://spdx.dev/ids/).
diff --git a/primitives/contrib/extra_lints.sh b/primitives/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/primitives/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 42e6ca10ec..8b9f212a2c 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -7,23 +7,44 @@
 //! module describes structures and functions needed to describe
 //! these blocks and the blockchain.
 
+use core::convert::Infallible;
 use core::fmt;
 #[cfg(feature = "alloc")]
 use core::marker::PhantomData;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use encoding::Encodable;
+#[cfg(feature = "hex")]
+use encoding::EncodableByteIter;
+#[cfg(feature = "alloc")]
+use encoding::{
+    CompactSizeEncoder, Decodable, Decoder, Decoder2, Decoder6, Encoder2, SliceEncoder, VecDecoder,
+};
 use hashes::{sha256d, HashEngine as _};
-use units::BlockTime;
+use internals::write_err;
 
-use crate::merkle_tree::TxMerkleNode;
 #[cfg(feature = "alloc")]
-use crate::merkle_tree::WitnessMerkleNode;
-use crate::pow::CompactTarget;
+use crate::pow::{CompactTargetDecoder, CompactTargetDecoderError};
 #[cfg(feature = "alloc")]
 use crate::prelude::Vec;
 #[cfg(feature = "alloc")]
-use crate::transaction::Transaction;
+use crate::transaction::{TxMerkleNodeDecoder, TxMerkleNodeDecoderError};
+use crate::{BlockTime, CompactTarget, TxMerkleNode};
+#[cfg(feature = "alloc")]
+use crate::{BlockTimeDecoder, BlockTimeDecoderError, Transaction, WitnessMerkleNode};
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(inline)]
+pub use units::block::{BlockHeight, BlockHeightDecoder, BlockHeightEncoder, BlockHeightInterval, BlockMtp, BlockMtpInterval};
+// Re-export errors that appear directly in the API - but no doc inline.
+#[doc(no_inline)]
+pub use units::block::{BlockHeightDecoderError, TooBigForRelativeHeightError};
+
+#[doc(inline)]
+pub use crate::hash_types::{
+    BlockHash, BlockHashDecoder, BlockHashDecoderError, BlockHashEncoder, WitnessCommitment,
+};
 
 /// Marker for whether or not a block has been validated.
 ///
@@ -52,7 +73,6 @@ pub trait Validation: sealed::Validation + Sync + Send + Sized + Unpin {
 /// * [CBlock definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/block.h#L62)
 #[cfg(feature = "alloc")]
 #[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Block<V = Unchecked>
 where
     V: Validation,
@@ -61,19 +81,18 @@ where
     header: Header,
     /// List of transactions contained in the block
     transactions: Vec<Transaction>,
-    /// Cached witness root if its been computed.
-    #[cfg_attr(feature = "serde", serde(skip_serializing))]
+    /// Cached witness root if it's been computed.
     witness_root: Option<WitnessMerkleNode>,
     /// Validation marker.
-    marker: PhantomData<V>,
+    _marker: PhantomData<V>,
 }
 
 #[cfg(feature = "alloc")]
 impl Block<Unchecked> {
     /// Constructs a new `Block` without doing any validation.
     #[inline]
-    pub fn new_unchecked(header: Header, transactions: Vec<Transaction>) -> Block<Unchecked> {
-        Block { header, transactions, witness_root: None, marker: PhantomData::<Unchecked> }
+    pub fn new_unchecked(header: Header, transactions: Vec<Transaction>) -> Self {
+        Self { header, transactions, witness_root: None, _marker: PhantomData::<Unchecked> }
     }
 
     /// Ignores block validation logic and just assumes you know what you are doing.
@@ -86,13 +105,105 @@ impl Block<Unchecked> {
             header: self.header,
             transactions: self.transactions,
             witness_root,
-            marker: PhantomData::<Checked>,
+            _marker: PhantomData::<Checked>,
         }
     }
 
     /// Decomposes block into its constituent parts.
     #[inline]
     pub fn into_parts(self) -> (Header, Vec<Transaction>) { (self.header, self.transactions) }
+
+    /// Validates (or checks) a block.
+    ///
+    /// We define valid as:
+    ///
+    /// * The Merkle root of the header matches Merkle root of the transaction list.
+    /// * The witness commitment in coinbase matches the transaction list.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// * The block has no transactions.
+    /// * The first transaction is not a coinbase transaction.
+    /// * The Merkle root of the header does not match the Merkle root of the transaction list.
+    /// * The witness commitment in the coinbase does not match the transaction list.
+    pub fn validate(self) -> Result<Block<Checked>, InvalidBlockError> {
+        if self.transactions.is_empty() {
+            return Err(InvalidBlockError::NoTransactions);
+        }
+
+        if !self.transactions[0].is_coinbase() {
+            return Err(InvalidBlockError::InvalidCoinbase);
+        }
+
+        if !self.check_merkle_root() {
+            return Err(InvalidBlockError::InvalidMerkleRoot);
+        }
+
+        match self.check_witness_commitment() {
+            (false, _) => Err(InvalidBlockError::InvalidWitnessCommitment),
+            (true, witness_root) => {
+                let block = Self::new_unchecked(self.header, self.transactions);
+                Ok(block.assume_checked(witness_root))
+            }
+        }
+    }
+
+    /// Checks if Merkle root of header matches Merkle root of the transaction list.
+    pub fn check_merkle_root(&self) -> bool {
+        match compute_merkle_root(&self.transactions) {
+            Some(merkle_root) => self.header.merkle_root == merkle_root,
+            None => false,
+        }
+    }
+
+    /// Computes the witness commitment for a list of transactions.
+    pub fn compute_witness_commitment(
+        &self,
+        witness_reserved_value: &[u8],
+    ) -> Option<(WitnessMerkleNode, WitnessCommitment)> {
+        compute_witness_root(&self.transactions).map(|witness_root| {
+            let mut encoder = sha256d::Hash::engine();
+            encoder = hashes::encode_to_engine(&witness_root, encoder);
+            encoder.input(witness_reserved_value);
+            let witness_commitment = WitnessCommitment::from_byte_array(
+                sha256d::Hash::from_engine(encoder).to_byte_array(),
+            );
+            (witness_root, witness_commitment)
+        })
+    }
+
+    /// Checks if witness commitment in coinbase matches the transaction list.
+    // Returns the Merkle root if it was computed (so it can be cached in `assume_checked`).
+    pub fn check_witness_commitment(&self) -> (bool, Option<WitnessMerkleNode>) {
+        if self.transactions.is_empty() {
+            return (false, None);
+        }
+
+        // Witness commitment is optional if there are no transactions using SegWit in the block.
+        if self.transactions.iter().all(|t| t.inputs.iter().all(|i| i.witness.is_empty())) {
+            return (true, None);
+        }
+
+        if self.transactions[0].is_coinbase() {
+            let coinbase = self.transactions[0].clone();
+            if let Some(commitment) = witness_commitment_from_coinbase(&coinbase) {
+                // Witness reserved value is in coinbase input witness.
+                let witness_vec: Vec<_> = coinbase.inputs[0].witness.iter().collect();
+                if witness_vec.len() == 1 && witness_vec[0].len() == 32 {
+                    if let Some((witness_root, witness_commitment)) =
+                        self.compute_witness_commitment(witness_vec[0])
+                    {
+                        if commitment == witness_commitment {
+                            return (true, Some(witness_root));
+                        }
+                    }
+                }
+            }
+        }
+
+        (false, None)
+    }
 }
 
 #[cfg(feature = "alloc")]
@@ -123,13 +234,13 @@ impl<V: Validation> Block<V> {
 #[cfg(feature = "alloc")]
 impl From<Block> for BlockHash {
     #[inline]
-    fn from(block: Block) -> BlockHash { block.block_hash() }
+    fn from(block: Block) -> Self { block.block_hash() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Block> for BlockHash {
     #[inline]
-    fn from(block: &Block) -> BlockHash { block.block_hash() }
+    fn from(block: &Block) -> Self { block.block_hash() }
 }
 
 /// Marker that the block's merkle root has been successfully validated.
@@ -160,6 +271,198 @@ mod sealed {
     impl Validation for super::Unchecked {}
 }
 
+#[cfg(feature = "alloc")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`Block`] type.
+    pub struct BlockEncoder<'e>(
+        Encoder2<HeaderEncoder, Encoder2<CompactSizeEncoder, SliceEncoder<'e, Transaction>>>
+    );
+}
+
+#[cfg(feature = "alloc")]
+impl Encodable for Block {
+    type Encoder<'e>
+        = Encoder2<HeaderEncoder, Encoder2<CompactSizeEncoder, SliceEncoder<'e, Transaction>>>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder2::new(
+            self.header.encoder(),
+            Encoder2::new(
+                CompactSizeEncoder::new(self.transactions.len()),
+                SliceEncoder::without_length_prefix(&self.transactions),
+            ),
+        )
+    }
+}
+
+#[cfg(feature = "alloc")]
+type BlockInnerDecoder = Decoder2<HeaderDecoder, VecDecoder<Transaction>>;
+
+/// The decoder for the [`Block`] type.
+///
+/// This decoder can only produce a `Block<Unchecked>`.
+#[cfg(feature = "alloc")]
+pub struct BlockDecoder(BlockInnerDecoder);
+
+#[cfg(feature = "alloc")]
+impl Decoder for BlockDecoder {
+    type Output = Block;
+    type Error = BlockDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(BlockDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (header, transactions) = self.0.end().map_err(BlockDecoderError)?;
+        Ok(Self::Output::new_unchecked(header, transactions))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "alloc")]
+impl Decodable for Block {
+    type Decoder = BlockDecoder;
+    fn decoder() -> Self::Decoder {
+        BlockDecoder(Decoder2::new(Header::decoder(), VecDecoder::<Transaction>::new()))
+    }
+}
+
+/// An error consensus decoding a [`Block`].
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockDecoderError(<BlockInnerDecoder as Decoder>::Error);
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for BlockDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for BlockDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self.0 {
+            encoding::Decoder2Error::First(ref e) => write_err!(f, "block decoder error"; e),
+            encoding::Decoder2Error::Second(ref e) => write_err!(f, "block decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg(feature = "std")]
+impl std::error::Error for BlockDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.0 {
+            encoding::Decoder2Error::First(ref e) => Some(e),
+            encoding::Decoder2Error::Second(ref e) => Some(e),
+        }
+    }
+}
+
+/// Invalid block error.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum InvalidBlockError {
+    /// Header Merkle root does not match the calculated Merkle root.
+    InvalidMerkleRoot,
+    /// The witness commitment in coinbase transaction does not match the calculated `witness_root`.
+    InvalidWitnessCommitment,
+    /// Block has no transactions (missing coinbase).
+    NoTransactions,
+    /// The first transaction is not a valid coinbase transaction.
+    InvalidCoinbase,
+}
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for InvalidBlockError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for InvalidBlockError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::InvalidMerkleRoot =>
+                write!(f, "header Merkle root does not match the calculated Merkle root"),
+            Self::InvalidWitnessCommitment => write!(f, "the witness commitment in coinbase transaction does not match the calculated witness_root"),
+            Self::NoTransactions => write!(f, "block has no transactions (missing coinbase)"),
+            Self::InvalidCoinbase =>
+                write!(f, "the first transaction is not a valid coinbase transaction"),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidBlockError {}
+
+/// Computes the Merkle root for a list of transactions.
+///
+/// Returns `None` if the iterator was empty, or if the transaction list contains
+/// consecutive duplicates which would trigger CVE 2012-2459. Blocks with duplicate
+/// transactions will always be invalid, so there is no harm in us refusing to
+/// compute their merkle roots.
+///
+/// Unless you are certain your transaction list is nonempty and has no duplicates,
+/// you should not unwrap the `Option` returned by this method!
+#[cfg(feature = "alloc")]
+pub fn compute_merkle_root(transactions: &[Transaction]) -> Option<TxMerkleNode> {
+    let hashes = transactions.iter().map(Transaction::compute_txid);
+    TxMerkleNode::calculate_root(hashes)
+}
+
+/// Computes the Merkle root of transactions hashed for witness.
+///
+/// Returns `None` if the iterator was empty, or if the transaction list contains
+/// consecutive duplicates which would trigger CVE 2012-2459. Blocks with duplicate
+/// transactions will always be invalid, so there is no harm in us refusing to
+/// compute their merkle roots.
+///
+/// Unless you are certain your transaction list is nonempty and has no duplicates,
+/// you should not unwrap the `Option` returned by this method!
+#[cfg(feature = "alloc")]
+pub fn compute_witness_root(transactions: &[Transaction]) -> Option<WitnessMerkleNode> {
+    let hashes = transactions.iter().enumerate().map(|(i, t)| {
+        if i == 0 {
+            // Replace the first hash with zeroes.
+            crate::Wtxid::COINBASE
+        } else {
+            t.compute_wtxid()
+        }
+    });
+    WitnessMerkleNode::calculate_root(hashes)
+}
+
+#[cfg(feature = "alloc")]
+fn witness_commitment_from_coinbase(coinbase: &Transaction) -> Option<WitnessCommitment> {
+    // Consists of OP_RETURN, OP_PUSHBYTES_36, and four "witness header" bytes.
+    const MAGIC: [u8; 6] = [0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
+
+    if !coinbase.is_coinbase() {
+        return None;
+    }
+
+    // Commitment is in the last output that starts with magic bytes.
+    if let Some(pos) = coinbase
+        .outputs
+        .iter()
+        .rposition(|o| o.script_pubkey.len() >= 38 && o.script_pubkey.as_bytes()[0..6] == MAGIC)
+    {
+        let bytes =
+            <[u8; 32]>::try_from(&coinbase.outputs[pos].script_pubkey.as_bytes()[6..38]).unwrap();
+        Some(WitnessCommitment::from_byte_array(bytes))
+    } else {
+        None
+    }
+}
+
 /// Bitcoin block header.
 ///
 /// Contains all the block's information except the actual transactions, but
@@ -171,7 +474,6 @@ mod sealed {
 ///
 /// * [CBlockHeader definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/block.h#L20)
 #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Header {
     /// Block version, now repurposed for soft fork signalling.
     pub version: Version,
@@ -195,37 +497,18 @@ impl Header {
     /// Returns the block hash.
     // This is the same as `Encodable` but done manually because `Encodable` isn't in `primitives`.
     pub fn block_hash(&self) -> BlockHash {
-        let mut engine = sha256d::Hash::engine();
-        engine.input(&self.version.to_consensus().to_le_bytes());
-        engine.input(self.prev_blockhash.as_byte_array());
-        engine.input(self.merkle_root.as_byte_array());
-        engine.input(&self.time.to_u32().to_le_bytes());
-        engine.input(&self.bits.to_consensus().to_le_bytes());
-        engine.input(&self.nonce.to_le_bytes());
-
-        BlockHash::from_byte_array(sha256d::Hash::from_engine(engine).to_byte_array())
+        let bare_hash = hashes::encode_to_engine(self, sha256d::Hash::engine()).finalize();
+        BlockHash::from_byte_array(bare_hash.to_byte_array())
     }
 }
 
 #[cfg(feature = "hex")]
 impl fmt::Display for Header {
+    #[allow(clippy::use_self)]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use fmt::Write as _;
-        use hex::DisplayHex as _;
-
-        let mut buf = arrayvec::ArrayString::<160>::new();
-        write!(
-            &mut buf,
-            "{}{}{}{}{}{}",
-            self.version.to_consensus().to_le_bytes().as_hex(),
-            self.prev_blockhash.as_byte_array().as_hex(),
-            self.merkle_root.as_byte_array().as_hex(),
-            self.time.to_u32().to_le_bytes().as_hex(),
-            self.bits.to_consensus().to_le_bytes().as_hex(),
-            self.nonce.to_le_bytes().as_hex(),
-        )
-        .expect("total length of written objects is 160 characters");
-        fmt::Display::fmt(&buf, f)
+        use hex_unstable::{fmt_hex_exact, Case};
+
+        fmt_hex_exact!(f, Header::SIZE, HeaderIter(EncodableByteIter::new(self)), Case::Lower)
     }
 }
 
@@ -243,29 +526,193 @@ impl fmt::Debug for Header {
     }
 }
 
+/// A wrapper around [`encoding::EncodableByteIter`]
+///
+/// This wrapper implements `ExactSizeIterator` for use with `fmt_hex_exact!`.
+#[cfg(feature = "hex")]
+struct HeaderIter<'a>(EncodableByteIter<'a, Header>);
+
+#[cfg(feature = "hex")]
+impl Iterator for HeaderIter<'_> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> { self.0.next() }
+
+    fn size_hint(&self) -> (usize, Option<usize>) { (Header::SIZE, Some(Header::SIZE)) }
+}
+#[cfg(feature = "hex")]
+impl ExactSizeIterator for HeaderIter<'_> {}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`Header`] type.
+    pub struct HeaderEncoder(
+        encoding::Encoder6<
+            VersionEncoder,
+            BlockHashEncoder,
+            crate::merkle_tree::TxMerkleNodeEncoder,
+            crate::time::BlockTimeEncoder,
+            crate::pow::CompactTargetEncoder,
+            encoding::ArrayEncoder<4>,
+        >
+    );
+}
+
+impl Encodable for Header {
+    type Encoder<'e> = HeaderEncoder;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        HeaderEncoder(encoding::Encoder6::new(
+            self.version.encoder(),
+            self.prev_blockhash.encoder(),
+            self.merkle_root.encoder(),
+            self.time.encoder(),
+            self.bits.encoder(),
+            encoding::ArrayEncoder::without_length_prefix(self.nonce.to_le_bytes()),
+        ))
+    }
+}
+
+#[cfg(feature = "alloc")]
+type HeaderInnerDecoder = Decoder6<
+    VersionDecoder,
+    BlockHashDecoder,
+    TxMerkleNodeDecoder,
+    BlockTimeDecoder,
+    CompactTargetDecoder,
+    encoding::ArrayDecoder<4>, // Nonce
+>;
+
+/// The decoder for the [`Header`] type.
+#[cfg(feature = "alloc")]
+pub struct HeaderDecoder(HeaderInnerDecoder);
+
+#[cfg(feature = "alloc")]
+impl HeaderDecoder {
+    fn from_inner(e: <HeaderInnerDecoder as Decoder>::Error) -> HeaderDecoderError {
+        match e {
+            encoding::Decoder6Error::First(e) => HeaderDecoderError::Version(e),
+            encoding::Decoder6Error::Second(e) => HeaderDecoderError::PrevBlockhash(e),
+            encoding::Decoder6Error::Third(e) => HeaderDecoderError::MerkleRoot(e),
+            encoding::Decoder6Error::Fourth(e) => HeaderDecoderError::Time(e),
+            encoding::Decoder6Error::Fifth(e) => HeaderDecoderError::Bits(e),
+            encoding::Decoder6Error::Sixth(e) => HeaderDecoderError::Nonce(e),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Decoder for HeaderDecoder {
+    type Output = Header;
+    type Error = HeaderDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(Self::from_inner)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (version, prev_blockhash, merkle_root, time, bits, nonce) =
+            self.0.end().map_err(Self::from_inner)?;
+        let nonce = u32::from_le_bytes(nonce);
+        Ok(Header { version, prev_blockhash, merkle_root, time, bits, nonce })
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "alloc")]
+impl Decodable for Header {
+    type Decoder = HeaderDecoder;
+    fn decoder() -> Self::Decoder {
+        HeaderDecoder(Decoder6::new(
+            VersionDecoder::new(),
+            BlockHashDecoder::new(),
+            TxMerkleNodeDecoder::new(),
+            BlockTimeDecoder::new(),
+            CompactTargetDecoder::new(),
+            encoding::ArrayDecoder::new(),
+        ))
+    }
+}
+
+/// An error consensus decoding a `Header`.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum HeaderDecoderError {
+    /// Error while decoding the `version`.
+    Version(VersionDecoderError),
+    /// Error while decoding the `prev_blockhash`.
+    PrevBlockhash(BlockHashDecoderError),
+    /// Error while decoding the `merkle_root`.
+    MerkleRoot(TxMerkleNodeDecoderError),
+    /// Error while decoding the `time`.
+    Time(BlockTimeDecoderError),
+    /// Error while decoding the `bits`.
+    Bits(CompactTargetDecoderError),
+    /// Error while decoding the `nonce`.
+    Nonce(encoding::UnexpectedEofError),
+}
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for HeaderDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for HeaderDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Version(ref e) => write_err!(f, "header decoder error"; e),
+            Self::PrevBlockhash(ref e) => write_err!(f, "header decoder error"; e),
+            Self::MerkleRoot(ref e) => write_err!(f, "header decoder error"; e),
+            Self::Time(ref e) => write_err!(f, "header decoder error"; e),
+            Self::Bits(ref e) => write_err!(f, "header decoder error"; e),
+            Self::Nonce(ref e) => write_err!(f, "header decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
+impl std::error::Error for HeaderDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Version(ref e) => Some(e),
+            Self::PrevBlockhash(ref e) => Some(e),
+            Self::MerkleRoot(ref e) => Some(e),
+            Self::Time(ref e) => Some(e),
+            Self::Bits(ref e) => Some(e),
+            Self::Nonce(ref e) => Some(e),
+        }
+    }
+}
+
 impl From<Header> for BlockHash {
     #[inline]
-    fn from(header: Header) -> BlockHash { header.block_hash() }
+    fn from(header: Header) -> Self { header.block_hash() }
 }
 
 impl From<&Header> for BlockHash {
     #[inline]
-    fn from(header: &Header) -> BlockHash { header.block_hash() }
+    fn from(header: &Header) -> Self { header.block_hash() }
 }
 
 /// Bitcoin block version number.
 ///
 /// Originally used as a protocol version, but repurposed for soft-fork signaling.
 ///
-/// The inner value is a signed integer in Bitcoin Core for historical reasons, if version bits is
+/// The inner value is a signed integer in Bitcoin Core for historical reasons, if the version bits are
 /// being used the top three bits must be 001, this gives us a useful range of [0x20000000...0x3FFFFFFF].
 ///
 /// > When a block nVersion does not have top bits 001, it is treated as if all bits are 0 for the purposes of deployments.
 ///
 /// # Relevant BIPs
 ///
-/// * [BIP9 - Version bits with timeout and delay](https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki) (current usage)
-/// * [BIP34 - Block v2, Height in Coinbase](https://github.com/bitcoin/bips/blob/master/bip-0034.mediawiki)
+/// * [BIP-0009 - Version bits with timeout and delay](https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki) (current usage)
+/// * [BIP-0034 - Block v2, Height in Coinbase](https://github.com/bitcoin/bips/blob/master/bip-0034.mediawiki)
 #[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Version(i32);
@@ -274,13 +721,13 @@ impl Version {
     /// The original Bitcoin Block v1.
     pub const ONE: Self = Self(1);
 
-    /// BIP-34 Block v2.
+    /// BIP-0034 Block v2.
     pub const TWO: Self = Self(2);
 
-    /// BIP-9 compatible version number that does not signal for any softforks.
+    /// BIP-0009 compatible version number that does not signal for any softforks.
     pub const NO_SOFT_FORK_SIGNALLING: Self = Self(Self::USE_VERSION_BITS as i32);
 
-    /// BIP-9 soft fork signal bits mask.
+    /// BIP-0009 soft fork signal bits mask.
     const VERSION_BITS_MASK: u32 = 0x1FFF_FFFF;
 
     /// 32bit value starting with `001` to use version bits.
@@ -292,17 +739,17 @@ impl Version {
     ///
     /// This is the data type used in consensus code in Bitcoin Core.
     #[inline]
-    pub const fn from_consensus(v: i32) -> Self { Version(v) }
+    pub const fn from_consensus(v: i32) -> Self { Self(v) }
 
     /// Returns the inner `i32` value.
     ///
     /// This is the data type used in consensus code in Bitcoin Core.
     #[inline]
-    pub fn to_consensus(self) -> i32 { self.0 }
+    pub const fn to_consensus(self) -> i32 { self.0 }
 
     /// Checks whether the version number is signalling a soft fork at the given bit.
     ///
-    /// A block is signalling for a soft fork under BIP-9 if the first 3 bits are `001` and
+    /// A block is signalling for a soft fork under BIP-0009 if the first 3 bits are `001` and
     /// the version bit for the specific soft fork is toggled on.
     pub fn is_signalling_soft_fork(self, bit: u8) -> bool {
         // Only bits [0, 28] inclusive are used for signalling.
@@ -322,26 +769,80 @@ impl Version {
 
 impl Default for Version {
     #[inline]
-    fn default() -> Version { Self::NO_SOFT_FORK_SIGNALLING }
+    fn default() -> Self { Self::NO_SOFT_FORK_SIGNALLING }
 }
 
-hashes::hash_newtype! {
-    /// A bitcoin block hash.
-    pub struct BlockHash(sha256d::Hash);
-    /// A hash corresponding to the witness structure commitment in the coinbase transaction.
-    pub struct WitnessCommitment(sha256d::Hash);
+encoding::encoder_newtype! {
+    /// The encoder for the [`Version`] type.
+    pub struct VersionEncoder(encoding::ArrayEncoder<4>);
 }
 
-#[cfg(feature = "hex")]
-hashes::impl_hex_for_newtype!(BlockHash, WitnessCommitment);
-#[cfg(not(feature = "hex"))]
-hashes::impl_debug_only_for_newtype!(BlockHash, WitnessCommitment);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(BlockHash, WitnessCommitment);
+impl Encodable for Version {
+    type Encoder<'e> = VersionEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        VersionEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_consensus().to_le_bytes(),
+        ))
+    }
+}
+
+/// The decoder for the [`Version`] type.
+pub struct VersionDecoder(encoding::ArrayDecoder<4>);
+
+impl VersionDecoder {
+    /// Constructs a new [`Version`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for VersionDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for VersionDecoder {
+    type Output = Version;
+    type Error = VersionDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = i32::from_le_bytes(self.0.end()?);
+        Ok(Version::from_consensus(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for Version {
+    type Decoder = VersionDecoder;
+    fn decoder() -> Self::Decoder { VersionDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `Version`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VersionDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for VersionDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<encoding::UnexpectedEofError> for VersionDecoderError {
+    fn from(e: encoding::UnexpectedEofError) -> Self { Self(e) }
+}
 
-impl BlockHash {
-    /// Dummy hash used as the previous blockhash of the genesis block.
-    pub const GENESIS_PREVIOUS_BLOCK_HASH: Self = Self::from_byte_array([0; 32]);
+impl fmt::Display for VersionDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "version decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for VersionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
 }
 
 #[cfg(feature = "arbitrary")]
@@ -350,14 +851,14 @@ impl<'a> Arbitrary<'a> for Block {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let header = Header::arbitrary(u)?;
         let transactions = Vec::<Transaction>::arbitrary(u)?;
-        Ok(Block::new_unchecked(header, transactions))
+        Ok(Self::new_unchecked(header, transactions))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Header {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Header {
+        Ok(Self {
             version: Version::arbitrary(u)?,
             prev_blockhash: BlockHash::from_byte_array(u.arbitrary()?),
             merkle_root: TxMerkleNode::from_byte_array(u.arbitrary()?),
@@ -374,16 +875,19 @@ impl<'a> Arbitrary<'a> for Version {
         // Equally weight known versions and arbitrary versions
         let choice = u.int_in_range(0..=3)?;
         match choice {
-            0 => Ok(Version::ONE),
-            1 => Ok(Version::TWO),
-            2 => Ok(Version::NO_SOFT_FORK_SIGNALLING),
-            _ => Ok(Version::from_consensus(u.arbitrary()?)),
+            0 => Ok(Self::ONE),
+            1 => Ok(Self::TWO),
+            2 => Ok(Self::NO_SOFT_FORK_SIGNALLING),
+            _ => Ok(Self::from_consensus(u.arbitrary()?)),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::{format, vec};
+
     use super::*;
 
     fn dummy_header() -> Header {
@@ -443,7 +947,7 @@ mod tests {
         let header = dummy_header();
 
         // Calculate the size of the block header in bytes from the sum of the serialized lengths
-        // it's fields: version, prev_blockhash, merkle_root, time, bits, nonce.
+        // its fields: version, prev_blockhash, merkle_root, time, bits, nonce.
         let header_size = header.version.to_consensus().to_le_bytes().len()
             + header.prev_blockhash.as_byte_array().len()
             + header.merkle_root.as_byte_array().len()
@@ -499,6 +1003,72 @@ mod tests {
         assert_eq!(checked_block.cached_witness_root(), witness_root);
     }
 
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_validation_no_transactions() {
+        let header = dummy_header();
+        let transactions = Vec::new(); // Empty transactions
+
+        let block = Block::new_unchecked(header, transactions);
+        match block.validate() {
+            Err(InvalidBlockError::NoTransactions) => (),
+            other => panic!("Expected NoTransactions error, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_validation_invalid_coinbase() {
+        let header = dummy_header();
+
+        // Create a non-coinbase transaction (has a real previous output, not all zeros)
+        let non_coinbase_tx = Transaction {
+            version: crate::transaction::Version::TWO,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![crate::TxIn {
+                previous_output: crate::OutPoint {
+                    txid: crate::Txid::from_byte_array([1; 32]), // Not all zeros
+                    vout: 0,
+                },
+                script_sig: crate::ScriptSigBuf::new(),
+                sequence: units::Sequence::ENABLE_LOCKTIME_AND_RBF,
+                witness: crate::Witness::new(),
+            }],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::ONE_BTC,
+                script_pubkey: crate::ScriptPubKeyBuf::new(),
+            }],
+        };
+
+        let transactions = vec![non_coinbase_tx];
+        let block = Block::new_unchecked(header, transactions);
+
+        match block.validate() {
+            Err(InvalidBlockError::InvalidCoinbase) => (),
+            other => panic!("Expected InvalidCoinbase error, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_check_witness_commitment_optional() {
+        // Valid block with optional witness commitment
+        let mut header = dummy_header();
+        header.merkle_root = TxMerkleNode::from_byte_array([0u8; 32]);
+        let coinbase = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![crate::TxIn::EMPTY_COINBASE],
+            outputs: vec![],
+        };
+
+        let transactions = vec![coinbase];
+        let block = Block::new_unchecked(header, transactions);
+
+        let result = block.check_witness_commitment();
+        assert_eq!(result, (true, None));
+    }
+
     #[test]
     #[cfg(feature = "alloc")]
     fn block_block_hash() {
@@ -543,6 +1113,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn header_debug() {
         let header = dummy_header();
         let expected = format!(
@@ -560,6 +1131,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "hex")]
+    #[cfg(feature = "alloc")]
     fn header_display() {
         let seconds: u32 = 1_653_195_600; // Arbitrary timestamp: May 22nd, 5am UTC.
 
@@ -588,4 +1160,203 @@ mod tests {
         let got = format!("{:.20}", header);
         assert_eq!(got, want);
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_decode() {
+        // Make a simple block, encode then decode. Verify equivalence.
+        let header = Header {
+            version: Version::ONE,
+            #[rustfmt::skip]
+            prev_blockhash: BlockHash::from_byte_array([
+                0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA,
+                0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA,
+                0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA,
+                0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA, 0xDC, 0xBA,
+            ]),
+            #[rustfmt::skip]
+            merkle_root: TxMerkleNode::from_byte_array([
+                0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD,
+                0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD,
+                0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD,
+                0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD,
+            ]),
+            time: BlockTime::from(1_742_979_600), // 26 Mar 2025 9:00 UTC
+            bits: CompactTarget::from_consensus(12_345_678),
+            nonce: 1024,
+        };
+
+        let block: u32 = 741_521;
+        let transactions = vec![Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: units::absolute::LockTime::from_height(block).unwrap(),
+            inputs: vec![crate::transaction::TxIn::EMPTY_COINBASE],
+            outputs: Vec::new(),
+        }];
+        let original_block = Block::new_unchecked(header, transactions);
+
+        // Encode + decode the block
+        let encoded = encoding::encode_to_vec(&original_block);
+        let decoded_block = encoding::decode_from_slice(encoded.as_slice()).unwrap();
+
+        assert_eq!(original_block, decoded_block);
+    }
+
+    // Test vector provided by tm0 in issue #5023
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn merkle_tree_hash_collision() {
+        // https://learnmeabitcoin.com/explorer/block/00000000000008a662b4a95a46e4c54cb04852525ac0ef67d1bcac85238416d4
+        // this block has 7 transactions
+        const BLOCK_128461_HEX: &str = "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";
+        let bytes: [u8; 1948] = hex_unstable::FromHex::from_hex(BLOCK_128461_HEX).unwrap();
+        let valid_block: Block<Unchecked> = encoding::decode_from_slice(&bytes).unwrap();
+        let (header, mut transactions) = valid_block.clone().into_parts();
+        transactions.push(transactions[6].clone());
+        let forged_block = Block::new_unchecked(header, transactions);
+
+        assert!(valid_block.validate().is_ok());
+        assert!(forged_block.validate().is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn witness_commitment_from_coinbase_simple() {
+        // Add witness commitment to the coinbase
+        let magic = [0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
+        let mut pubkey_bytes = [0; 38];
+        pubkey_bytes[0..6].copy_from_slice(&magic);
+        let witness_commitment =
+            WitnessCommitment::from_byte_array(pubkey_bytes[6..38].try_into().unwrap());
+        let commitment_script = crate::script::ScriptBuf::from_bytes(pubkey_bytes.to_vec());
+
+        // Create a coinbase transaction with witness commitment
+        let tx = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![crate::TxIn::EMPTY_COINBASE],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                script_pubkey: commitment_script,
+            }],
+        };
+
+        // Test if the witness commitment is extracted properly
+        let extracted = witness_commitment_from_coinbase(&tx);
+        assert_eq!(extracted, Some(witness_commitment));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_check_witness_commitment_empty_script_pubkey() {
+        let mut txin = crate::TxIn::EMPTY_COINBASE;
+        let push = [11_u8];
+        txin.witness.push(push);
+
+        let tx = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![txin],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                // Empty scriptbuf means there is no witness commitment due to no magic bytes.
+                script_pubkey: crate::script::ScriptBuf::new(),
+            }],
+        };
+
+        let block = Block::new_unchecked(dummy_header(), vec![tx]);
+        let result = block.check_witness_commitment();
+        assert_eq!(result, (false, None)); // (false, None) since there's no valid witness commitment
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_check_witness_commitment_no_transactions() {
+        // Test case of block with no transactions
+        let empty_block = Block::new_unchecked(dummy_header(), vec![]);
+        let result = empty_block.check_witness_commitment();
+        assert_eq!(result, (false, None));
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn block_check_witness_commitment_with_witness() {
+        let mut txin = crate::TxIn::EMPTY_COINBASE;
+        // Single witness item of 32 bytes.
+        let witness_bytes: [u8; 32] = [11u8; 32];
+        txin.witness.push(witness_bytes);
+
+        // pubkey bytes must match the magic bytes followed by the hash of the witness bytes.
+        let script_pubkey_bytes: [u8; 38] = hex_unstable::FromHex::from_hex(
+            "6a24aa21a9ed3cde9e0b9f4ad8f9d0fd66d6b9326cd68597c04fa22ab64b8e455f08d2e31ceb",
+        )
+        .unwrap();
+        let tx1 = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![txin],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                script_pubkey: crate::script::ScriptBuf::from_bytes(script_pubkey_bytes.to_vec()),
+            }],
+        };
+
+        let tx2 = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![crate::TxIn::EMPTY_COINBASE],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                script_pubkey: crate::script::ScriptBuf::new(),
+            }],
+        };
+
+        let block = Block::new_unchecked(dummy_header(), vec![tx1, tx2]);
+        let result = block.check_witness_commitment();
+
+        let exp_bytes: [u8; 32] = hex_unstable::FromHex::from_hex(
+            "fb848679079938b249a12f14b72d56aeb116df79254e17cdf72b46523bcb49db",
+        )
+        .unwrap();
+        let expected = WitnessMerkleNode::from_byte_array(exp_bytes);
+        assert_eq!(result, (true, Some(expected)));
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn block_check_witness_commitment_invalid_witness() {
+        let mut txin = crate::TxIn::EMPTY_COINBASE;
+        let witness_bytes: [u8; 32] = [11u8; 32];
+        // First witness item is 32 bytes, but there are two witness elements.
+        txin.witness.push(witness_bytes);
+        txin.witness.push([12u8]);
+
+        let script_pubkey_bytes: [u8; 38] = hex_unstable::FromHex::from_hex(
+            "6a24aa21a9ed3cde9e0b9f4ad8f9d0fd66d6b9326cd68597c04fa22ab64b8e455f08d2e31ceb",
+        )
+        .unwrap();
+        let tx1 = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![txin],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                script_pubkey: crate::script::ScriptBuf::from_bytes(script_pubkey_bytes.to_vec()),
+            }],
+        };
+
+        let tx2 = Transaction {
+            version: crate::transaction::Version::ONE,
+            lock_time: crate::absolute::LockTime::ZERO,
+            inputs: vec![crate::TxIn::EMPTY_COINBASE],
+            outputs: vec![crate::TxOut {
+                amount: units::Amount::MIN,
+                script_pubkey: crate::script::ScriptBuf::new(),
+            }],
+        };
+
+        let block = Block::new_unchecked(dummy_header(), vec![tx1, tx2]);
+        let result = block.check_witness_commitment();
+        assert_eq!(result, (false, None));
+    }
 }
diff --git a/primitives/src/hash_types/block_hash.rs b/primitives/src/hash_types/block_hash.rs
new file mode 100644
index 0000000000..ea0e35c0d9
--- /dev/null
+++ b/primitives/src/hash_types/block_hash.rs
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `BlockHash` type.
+
+use core::convert::Infallible;
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use encoding::Encodable;
+use hashes::sha256d;
+use internals::write_err;
+
+/// A bitcoin block hash.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct BlockHash(sha256d::Hash);
+
+impl BlockHash {
+    /// Dummy hash used as the previous blockhash of the genesis block.
+    pub const GENESIS_PREVIOUS_BLOCK_HASH: Self = Self::from_byte_array([0; 32]);
+}
+
+// The new hash wrapper type.
+type HashType = BlockHash;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`BlockHash`] type.
+    pub struct BlockHashEncoder(encoding::ArrayEncoder<32>);
+}
+
+impl Encodable for BlockHash {
+    type Encoder<'e> = BlockHashEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        BlockHashEncoder(encoding::ArrayEncoder::without_length_prefix(self.to_byte_array()))
+    }
+}
+
+/// The decoder for the [`BlockHash`] type.
+pub struct BlockHashDecoder(encoding::ArrayDecoder<32>);
+
+impl BlockHashDecoder {
+    /// Constructs a new [`BlockHash`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for BlockHashDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for BlockHashDecoder {
+    type Output = BlockHash;
+    type Error = BlockHashDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let a = self.0.end()?;
+        Ok(BlockHash::from_byte_array(a))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for BlockHash {
+    type Decoder = BlockHashDecoder;
+    fn decoder() -> Self::Decoder { BlockHashDecoder(encoding::ArrayDecoder::<32>::new()) }
+}
+
+/// An error consensus decoding an `BlockHash`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockHashDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for BlockHashDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<encoding::UnexpectedEofError> for BlockHashDecoderError {
+    fn from(e: encoding::UnexpectedEofError) -> Self { Self(e) }
+}
+
+impl fmt::Display for BlockHashDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "sequence decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BlockHashDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
diff --git a/primitives/src/hash_types/generic.rs b/primitives/src/hash_types/generic.rs
new file mode 100644
index 0000000000..50ba31deff
--- /dev/null
+++ b/primitives/src/hash_types/generic.rs
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: CC0-1.0
+
+// NOTE: This is not a normal module.
+//
+// Generic implementation of hash wrapper types.
+//
+// File is included in other files using `include!` allowing us to
+// follow the DRY principle without using macros.
+
+const LEN: usize = <Inner as hashes::Hash>::LEN;
+#[cfg(feature = "hex")]
+const REVERSE: bool =  <Inner as hashes::Hash>::DISPLAY_BACKWARD;
+
+impl HashType {
+    /// Constructs a new type from the underlying byte array.
+    pub const fn from_byte_array(bytes: [u8; LEN]) -> Self {
+        Self(Inner::from_byte_array(bytes))
+    }
+
+    /// Returns the underlying byte array.
+    pub const fn to_byte_array(self) -> [u8; LEN] { self.0.to_byte_array() }
+
+    /// Returns a reference to the underlying byte array.
+    pub const fn as_byte_array(&self) -> &[u8; LEN] { self.0.as_byte_array() }
+}
+
+#[cfg(feature = "serde")]
+super::impl_serde!(HashType, LEN);
+super::impl_bytelike_traits!(HashType, LEN);
+
+#[cfg(feature = "hex")]
+hex_unstable::impl_fmt_traits! {
+    #[display_backward(REVERSE)]
+    impl fmt_traits for HashType {
+        const LENGTH: usize = LEN;
+    }
+}
+
+#[cfg(feature = "hex")]
+impl str::FromStr for HashType {
+    type Err = hex::DecodeFixedLengthBytesError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut bytes = crate::hex::decode_to_array(s)?;
+
+        if REVERSE {
+            bytes.reverse();
+        }
+        Ok(Self::from_byte_array(bytes))
+    }
+}
+
+#[cfg(not(feature = "hex"))]
+impl fmt::Debug for HashType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for byte in self.as_byte_array() {
+            write!(f, "{:02x}", byte)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for HashType {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let arbitrary_bytes = u.arbitrary()?;
+        Ok(Self::from_byte_array(arbitrary_bytes))
+    }
+}
diff --git a/primitives/src/hash_types/mod.rs b/primitives/src/hash_types/mod.rs
new file mode 100644
index 0000000000..5bb54e15e2
--- /dev/null
+++ b/primitives/src/hash_types/mod.rs
@@ -0,0 +1,237 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Primitive hash wrapper types.
+//!
+//! Note: To print and parse these hash types enable the "hex" feature.
+
+mod block_hash;
+mod ntxid;
+#[cfg(feature = "alloc")]
+mod script_hash;
+mod transaction_merkle_node;
+mod txid;
+mod witness_commitment;
+mod witness_merkle_node;
+#[cfg(feature = "alloc")]
+mod witness_script_hash;
+mod wtxid;
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(inline)]
+pub use self::{
+    block_hash::{BlockHash, BlockHashDecoder, BlockHashDecoderError, BlockHashEncoder},
+    ntxid::Ntxid,
+    transaction_merkle_node::{TxMerkleNode, TxMerkleNodeEncoder, TxMerkleNodeDecoder, TxMerkleNodeDecoderError},
+    txid::{Txid},
+    wtxid::Wtxid,
+    witness_commitment::WitnessCommitment,
+    witness_merkle_node::WitnessMerkleNode,
+};
+#[cfg(feature = "alloc")]
+#[doc(inline)]
+pub use self::{
+    script_hash::{RedeemScriptSizeError, ScriptHash},
+    witness_script_hash::{WScriptHash, WitnessScriptSizeError},
+};
+
+/// Adds trait impls to a bytelike type.
+///
+/// Implements:
+///
+/// * `AsRef[u8; $len]`
+/// * `AsRef[u8]`
+/// * `Borrow<[u8; $len]>`
+/// * `Borrow<[u8]>`
+///
+/// # Parameters
+///
+/// * `ty` - the bytelike type to implement the traits on.
+/// * `$len` - the number of bytes this type has.
+/// * `$gen: $gent` - the generic type(s) and trait bound(s).
+macro_rules! impl_bytelike_traits {
+    ($ty:ident, $len:expr $(, $gen:ident: $gent:ident)*) => {
+        impl $crate::_export::_core::convert::AsRef<[u8; { $len }]> for $ty {
+            #[inline]
+            fn as_ref(&self) -> &[u8; { $len }] { self.as_byte_array() }
+        }
+
+        impl $crate::_export::_core::convert::AsRef<[u8]> for $ty {
+            #[inline]
+            fn as_ref(&self) -> &[u8] { self.as_byte_array() }
+        }
+
+        impl $crate::_export::_core::borrow::Borrow<[u8; { $len }]> for $ty {
+            fn borrow(&self) -> &[u8; { $len }] { self.as_byte_array() }
+        }
+
+        impl $crate::_export::_core::borrow::Borrow<[u8]> for $ty {
+            fn borrow(&self) -> &[u8] { self.as_byte_array() }
+        }
+    };
+}
+pub(in crate::hash_types) use impl_bytelike_traits;
+
+/// Implements `Serialize` and `Deserialize` for a hash wrapper type `$t`.
+///
+/// This is equivalent to `hashes::impl_serde_for_newtype` but does not rely on the wrapper type
+/// implementing the `Hash` trait.
+///
+/// Requires `$t` to implement:
+/// * `from_byte_array()`
+/// * `as_byte_array()`
+/// * `str::FromStr`
+/// * `fmt::Display`
+#[cfg(feature = "serde")]
+macro_rules! impl_serde(
+    ($t:ident, $len:expr) => (
+        impl $crate::serde::Serialize for $t {
+            fn serialize<S: $crate::serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
+                if s.is_human_readable() {
+                    s.collect_str(self)
+                } else {
+                    s.serialize_bytes(self.as_byte_array())
+                }
+            }
+        }
+
+        impl<'de> $crate::serde::Deserialize<'de> for $t {
+            fn deserialize<D: $crate::serde::Deserializer<'de>>(d: D) -> core::result::Result<$t, D::Error> {
+                use $crate::hash_types::serde_details::{BytesVisitor, HexVisitor};
+
+                if d.is_human_readable() {
+                    d.deserialize_str(HexVisitor::<Self>::default())
+                } else {
+                    let bytes = d.deserialize_bytes(BytesVisitor::<$len>::default())?;
+                    Ok(Self::from_byte_array(bytes))
+                }
+            }
+        }
+));
+#[cfg(feature = "serde")]
+pub(in crate::hash_types) use impl_serde;
+
+/// Functions used by serde impls of all hashes.
+#[cfg(feature = "serde")]
+pub mod serde_details {
+    use core::marker::PhantomData;
+    use core::str::FromStr;
+    use core::{fmt, str};
+
+    use serde::de;
+
+    /// Type used to implement serde traits for hashes as hex strings.
+    pub struct HexVisitor<ValueT>(PhantomData<ValueT>);
+
+    impl<ValueT> Default for HexVisitor<ValueT> {
+        fn default() -> Self { Self(PhantomData) }
+    }
+
+    impl<ValueT> de::Visitor<'_> for HexVisitor<ValueT>
+    where
+        ValueT: FromStr,
+        <ValueT as FromStr>::Err: fmt::Display,
+    {
+        type Value = ValueT;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("an ASCII hex string")
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            if let Ok(hex) = str::from_utf8(v) {
+                hex.parse::<Self::Value>().map_err(E::custom)
+            } else {
+                Err(E::invalid_value(de::Unexpected::Bytes(v), &self))
+            }
+        }
+
+        fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            v.parse::<Self::Value>().map_err(E::custom)
+        }
+    }
+
+    /// Type used to implement serde traits for hashes as bytes.
+    pub struct BytesVisitor<const N: usize>();
+
+    impl<const N: usize> Default for BytesVisitor<N> {
+        fn default() -> Self { Self() }
+    }
+
+    impl<const N: usize> de::Visitor<'_> for BytesVisitor<N> {
+        type Value = [u8; N];
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a bytestring")
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            let bytes = <[u8; N]>::try_from(v).map_err(|_| {
+                // from_slice only errors on incorrect length
+                E::invalid_length(v.len(), &stringify!(N))
+            })?;
+
+            Ok(bytes)
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "alloc")]
+mod tests {
+    use super::*;
+
+    // Creates an arbitrary dummy hash type object.
+    #[cfg(feature = "serde")]
+    fn dummy_test_case() -> Txid {
+        "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse::<Txid>().unwrap()
+    }
+
+    #[test]
+    #[cfg(feature = "serde")] // Implies alloc and hex
+    fn serde_human_readable_roundtrips() {
+        let tc = dummy_test_case();
+        let ser = serde_json::to_string(&tc).unwrap();
+        let got = serde_json::from_str::<Txid>(&ser).unwrap();
+        assert_eq!(got, tc);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")] // Implies alloc and hex
+    fn serde_non_human_readable_roundtrips() {
+        let tc = dummy_test_case();
+        let ser = bincode::serialize(&tc).unwrap();
+        let got = bincode::deserialize::<Txid>(&ser).unwrap();
+        assert_eq!(got, tc);
+    }
+
+    #[test]
+    // This is solely to test that we can debug print WITH "hex" so its ok to require "alloc".
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn debug() {
+        let tc = Txid::from_byte_array([0xab; 32]);
+        let got = alloc::format!("{:?}", tc);
+        let want = "abababababababababababababababababababababababababababababababab";
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    // This is solely to test that we can debug print WITHOUT "hex" so its ok to require "alloc".
+    #[cfg(feature = "alloc")]
+    #[cfg(not(feature = "hex"))]
+    fn debug() {
+        let tc = Txid::from_byte_array([0xab; 32]);
+        let got = alloc::format!("{:?}", tc);
+        let want = "abababababababababababababababababababababababababababababababab";
+        assert_eq!(got, want);
+    }
+}
diff --git a/primitives/src/hash_types/ntxid.rs b/primitives/src/hash_types/ntxid.rs
new file mode 100644
index 0000000000..df7a22bce2
--- /dev/null
+++ b/primitives/src/hash_types/ntxid.rs
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `Txid` type.
+
+#[cfg(not(feature = "hex"))]
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+
+/// A "normalized TXID".
+///
+/// Computed on a transaction that has had the signatures removed.
+///
+/// This type is needed only for legacy (pre-Segwit or P2SH-wrapped segwit version 0)
+/// applications. This method clears the `script_sig` field of each input, which in Segwit
+/// transactions is already empty, so for Segwit transactions the ntxid will be equal to the
+/// txid, and you should simply use the latter.
+///
+/// This gives a way to identify a transaction that is "the same" as another in the sense of
+/// having the same inputs and outputs.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Ntxid(sha256d::Hash);
+
+// The new hash wrapper type.
+type HashType = Ntxid;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
diff --git a/primitives/src/hash_types/script_hash.rs b/primitives/src/hash_types/script_hash.rs
new file mode 100644
index 0000000000..a4186a44f8
--- /dev/null
+++ b/primitives/src/hash_types/script_hash.rs
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `ScriptHash` type.
+
+use core::convert::Infallible;
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::hash160;
+
+use crate::script::{Script, ScriptHashableTag, MAX_REDEEM_SCRIPT_SIZE};
+
+/// A 160-bit hash of Bitcoin Script bytecode.
+///
+/// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
+/// uses 256-bit hash and hashes a semantically different script. Thus, this type cannot
+/// represent it.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ScriptHash(hash160::Hash);
+
+impl ScriptHash {
+    /// Constructs a new `ScriptHash` after first checking the script size.
+    ///
+    /// # 520-byte limitation on serialized script size
+    ///
+    /// > As a consequence of the requirement for backwards compatibility the serialized script is
+    /// > itself subject to the same rules as any other PUSHDATA operation, including the rule that
+    /// > no data greater than 520 bytes may be pushed to the stack. Thus it is not possible to
+    /// > spend a P2SH output if the redemption script it refers to is >520 bytes in length.
+    ///
+    /// ref: [BIP-0016](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the script exceeds 520 bytes.
+    #[inline]
+    pub fn from_script<T>(redeem_script: &Script<T>) -> Result<Self, RedeemScriptSizeError>
+    where
+        T: ScriptHashableTag,
+    {
+        if redeem_script.len() > MAX_REDEEM_SCRIPT_SIZE {
+            return Err(RedeemScriptSizeError { size: redeem_script.len() });
+        }
+
+        // We've just checked the length
+        Ok(Self::from_script_unchecked(redeem_script))
+    }
+
+    /// Constructs a new `ScriptHash` from any script irrespective of script size.
+    ///
+    /// If you hash a script that exceeds 520 bytes in size and use it to create a P2SH output
+    /// then the output will be unspendable (see [BIP-0016]).
+    ///
+    /// [BIP-0016]: <https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size>
+    #[inline]
+    pub fn from_script_unchecked<T>(script: &Script<T>) -> Self {
+        Self(hash160::Hash::hash(script.as_bytes()))
+    }
+}
+
+/// Error while hashing a redeem script.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RedeemScriptSizeError {
+    /// Invalid redeem script size (cannot exceed 520 bytes).
+    size: usize,
+}
+
+impl RedeemScriptSizeError {
+    /// Returns the invalid redeem script size.
+    pub fn invalid_size(&self) -> usize { self.size }
+}
+
+impl From<Infallible> for RedeemScriptSizeError {
+    #[inline]
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl fmt::Display for RedeemScriptSizeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "redeem script size exceeds {} bytes: {}", MAX_REDEEM_SCRIPT_SIZE, self.size)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RedeemScriptSizeError {}
+
+// The new hash wrapper type.
+type HashType = ScriptHash;
+// The inner hash type from `hashes`.
+type Inner = hash160::Hash;
+
+include!("./generic.rs");
diff --git a/primitives/src/hash_types/transaction_merkle_node.rs b/primitives/src/hash_types/transaction_merkle_node.rs
new file mode 100644
index 0000000000..8f962b1816
--- /dev/null
+++ b/primitives/src/hash_types/transaction_merkle_node.rs
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `TxMerkleNode` type.
+
+use core::convert::Infallible;
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+use internals::write_err;
+
+use crate::merkle_tree::MerkleNode;
+use crate::Txid;
+
+/// A hash of the Merkle tree branch or root for transactions.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TxMerkleNode(sha256d::Hash);
+
+// The new hash wrapper type.
+type HashType = TxMerkleNode;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
+
+impl TxMerkleNode {
+    /// Convert a [`Txid`] hash to a leaf node of the tree.
+    pub fn from_leaf(leaf: Txid) -> Self { MerkleNode::from_leaf(leaf) }
+
+    /// Combine two nodes to get a single node. The final node of a tree is called the "root".
+    #[must_use]
+    pub fn combine(&self, other: &Self) -> Self { MerkleNode::combine(self, other) }
+
+    /// Given an iterator of leaves, compute the Merkle root.
+    ///
+    /// Returns `None` if the iterator was empty, or if the transaction list contains
+    /// consecutive duplicates which would trigger CVE 2012-2459. Blocks with duplicate
+    /// transactions will always be invalid, so there is no harm in us refusing to
+    /// compute their merkle roots.
+    ///
+    /// Unless you are certain your transaction list is nonempty and has no duplicates,
+    /// you should not unwrap the `Option` returned by this method!
+    pub fn calculate_root<I: Iterator<Item = Txid>>(iter: I) -> Option<Self> {
+        MerkleNode::calculate_root(iter)
+    }
+}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`TxMerkleNode`] type.
+    pub struct TxMerkleNodeEncoder(encoding::ArrayEncoder<32>);
+}
+
+impl encoding::Encodable for TxMerkleNode {
+    type Encoder<'e> = TxMerkleNodeEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxMerkleNodeEncoder(encoding::ArrayEncoder::without_length_prefix(self.to_byte_array()))
+    }
+}
+
+/// The decoder for the [`TxMerkleNode`] type.
+pub struct TxMerkleNodeDecoder(encoding::ArrayDecoder<32>);
+
+impl TxMerkleNodeDecoder {
+    /// Constructs a new [`TxMerkleNode`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for TxMerkleNodeDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for TxMerkleNodeDecoder {
+    type Output = TxMerkleNode;
+    type Error = TxMerkleNodeDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let a = self.0.end()?;
+        Ok(TxMerkleNode::from_byte_array(a))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for TxMerkleNode {
+    type Decoder = TxMerkleNodeDecoder;
+    fn decoder() -> Self::Decoder { TxMerkleNodeDecoder(encoding::ArrayDecoder::<32>::new()) }
+}
+
+/// An error consensus decoding an `TxMerkleNode`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TxMerkleNodeDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for TxMerkleNodeDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<encoding::UnexpectedEofError> for TxMerkleNodeDecoderError {
+    fn from(e: encoding::UnexpectedEofError) -> Self { Self(e) }
+}
+
+impl fmt::Display for TxMerkleNodeDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "sequence decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TxMerkleNodeDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
diff --git a/primitives/src/hash_types/txid.rs b/primitives/src/hash_types/txid.rs
new file mode 100644
index 0000000000..b0d9fbf1fc
--- /dev/null
+++ b/primitives/src/hash_types/txid.rs
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `Txid` type.
+//!
+//! In order to print and parse txids enable the "hex" feature.
+
+#[cfg(not(feature = "hex"))]
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+
+#[cfg(doc)]
+use crate::OutPoint;
+
+/// A bitcoin transaction hash/transaction ID.
+///
+/// For compatibility with the existing Bitcoin infrastructure and historical and current
+/// versions of the Bitcoin Core software itself, this and other [`sha256d::Hash`] types, are
+/// serialized in reverse byte order when converted to a hex string via [`std::fmt::Display`]
+/// trait operations.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Txid(sha256d::Hash);
+
+impl Txid {
+    /// The `Txid` used in a coinbase prevout.
+    ///
+    /// This is used as the "txid" of the dummy input of a coinbase transaction. This is not a real
+    /// TXID and should not be used in any other contexts. See [`OutPoint::COINBASE_PREVOUT`].
+    pub const COINBASE_PREVOUT: Self = Self::from_byte_array([0; 32]);
+}
+
+// The new hash wrapper type.
+type HashType = Txid;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
diff --git a/primitives/src/hash_types/witness_commitment.rs b/primitives/src/hash_types/witness_commitment.rs
new file mode 100644
index 0000000000..f4332e960b
--- /dev/null
+++ b/primitives/src/hash_types/witness_commitment.rs
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `WitnessCommitment` type.
+
+#[cfg(not(feature = "hex"))]
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+
+/// A hash corresponding to the witness structure commitment in the coinbase transaction.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WitnessCommitment(sha256d::Hash);
+
+impl WitnessCommitment {
+    /// Dummy hash used as the previous blockhash of the genesis block.
+    pub const GENESIS_PREVIOUS_BLOCK_HASH: Self = Self::from_byte_array([0; 32]);
+}
+
+// The new hash wrapper type.
+type HashType = WitnessCommitment;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
diff --git a/primitives/src/hash_types/witness_merkle_node.rs b/primitives/src/hash_types/witness_merkle_node.rs
new file mode 100644
index 0000000000..4217bb45ff
--- /dev/null
+++ b/primitives/src/hash_types/witness_merkle_node.rs
@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `WitnessMerkleNode` type.
+
+use core::convert::Infallible;
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+use internals::write_err;
+
+use crate::merkle_tree::MerkleNode;
+use crate::Wtxid;
+
+/// A hash corresponding to the Merkle tree root for witness data.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WitnessMerkleNode(sha256d::Hash);
+
+// The new hash wrapper type.
+type HashType = WitnessMerkleNode;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
+
+impl WitnessMerkleNode {
+    /// Convert a [`Wtxid`] hash to a leaf node of the tree.
+    pub fn from_leaf(leaf: Wtxid) -> Self { MerkleNode::from_leaf(leaf) }
+
+    /// Combine two nodes to get a single node. The final node of a tree is called the "root".
+    #[must_use]
+    pub fn combine(&self, other: &Self) -> Self { MerkleNode::combine(self, other) }
+
+    /// Given an iterator of leaves, compute the Merkle root.
+    ///
+    /// Returns `None` if the iterator was empty, or if the transaction list contains
+    /// consecutive duplicates which would trigger CVE 2012-2459. Blocks with duplicate
+    /// transactions will always be invalid, so there is no harm in us refusing to
+    /// compute their merkle roots.
+    ///
+    /// Unless you are certain your transaction list is nonempty and has no duplicates,
+    /// you should not unwrap the `Option` returned by this method!
+    pub fn calculate_root<I: Iterator<Item = Wtxid>>(iter: I) -> Option<Self> {
+        MerkleNode::calculate_root(iter)
+    }
+}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`WitnessMerkleNode`] type.
+    pub struct WitnessMerkleNodeEncoder(encoding::ArrayEncoder<32>);
+}
+
+impl encoding::Encodable for WitnessMerkleNode {
+    type Encoder<'e> = WitnessMerkleNodeEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        WitnessMerkleNodeEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_byte_array(),
+        ))
+    }
+}
+
+/// The decoder for the [`WitnessMerkleNode`] type.
+pub struct WitnessMerkleNodeDecoder(encoding::ArrayDecoder<32>);
+
+impl WitnessMerkleNodeDecoder {
+    /// Constructs a new [`WitnessMerkleNode`] decoder.
+    pub fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for WitnessMerkleNodeDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for WitnessMerkleNodeDecoder {
+    type Output = WitnessMerkleNode;
+    type Error = WitnessMerkleNodeDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let a = self.0.end()?;
+        Ok(WitnessMerkleNode::from_byte_array(a))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for WitnessMerkleNode {
+    type Decoder = WitnessMerkleNodeDecoder;
+    fn decoder() -> Self::Decoder { WitnessMerkleNodeDecoder(encoding::ArrayDecoder::<32>::new()) }
+}
+
+/// An error consensus decoding an `WitnessMerkleNode`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WitnessMerkleNodeDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for WitnessMerkleNodeDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<encoding::UnexpectedEofError> for WitnessMerkleNodeDecoderError {
+    fn from(e: encoding::UnexpectedEofError) -> Self { Self(e) }
+}
+
+impl fmt::Display for WitnessMerkleNodeDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "sequence decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WitnessMerkleNodeDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
diff --git a/primitives/src/hash_types/witness_script_hash.rs b/primitives/src/hash_types/witness_script_hash.rs
new file mode 100644
index 0000000000..3ac39fe98e
--- /dev/null
+++ b/primitives/src/hash_types/witness_script_hash.rs
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `WScriptHash` type.
+
+use core::convert::Infallible;
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256;
+
+use crate::script::{WitnessScript, MAX_WITNESS_SCRIPT_SIZE};
+
+/// SegWit (256-bit) version of a Bitcoin Script bytecode hash.
+///
+/// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
+/// looks similar to this one also being SHA256, however, they hash semantically different
+/// scripts and have reversed representations, so this type cannot be used for both.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WScriptHash(sha256::Hash);
+
+impl WScriptHash {
+    /// Constructs a new `WScriptHash` after first checking the script size.
+    ///
+    /// # 10,000-byte limit on the witness script
+    ///
+    /// > The witnessScript (≤ 10,000 bytes) is popped off the initial witness stack. SHA256 of the
+    /// > witnessScript must match the 32-byte witness program.
+    ///
+    /// ref: [BIP-0141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the script exceeds 10,000 bytes.
+    #[inline]
+    pub fn from_script(witness_script: &WitnessScript) -> Result<Self, WitnessScriptSizeError> {
+        if witness_script.len() > MAX_WITNESS_SCRIPT_SIZE {
+            return Err(WitnessScriptSizeError { size: witness_script.len() });
+        }
+
+        // We've just checked the length
+        Ok(Self::from_script_unchecked(witness_script))
+    }
+
+    /// Constructs a new `WScriptHash` from any script irrespective of script size.
+    ///
+    /// If you hash a script that exceeds 10,000 bytes in size and use it to create a Segwit
+    /// output then the output will be unspendable (see [BIP-0141]).
+    ///
+    /// ref: [BIP-0141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    #[inline]
+    pub fn from_script_unchecked(script: &WitnessScript) -> Self {
+        Self(sha256::Hash::hash(script.as_bytes()))
+    }
+}
+
+/// Error while hashing a witness script.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WitnessScriptSizeError {
+    /// Invalid witness script size (cannot exceed 10,000 bytes).
+    size: usize,
+}
+
+impl WitnessScriptSizeError {
+    /// Returns the invalid witness script size.
+    pub fn invalid_size(&self) -> usize { self.size }
+}
+
+impl From<Infallible> for WitnessScriptSizeError {
+    #[inline]
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl fmt::Display for WitnessScriptSizeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "witness script size exceeds {} bytes: {}", MAX_WITNESS_SCRIPT_SIZE, self.size)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WitnessScriptSizeError {}
+
+include!("./generic.rs");
+
+// The new hash wrapper type.
+type HashType = WScriptHash;
+// The inner hash type from `hashes`.
+type Inner = sha256::Hash;
diff --git a/primitives/src/hash_types/wtxid.rs b/primitives/src/hash_types/wtxid.rs
new file mode 100644
index 0000000000..482623f50b
--- /dev/null
+++ b/primitives/src/hash_types/wtxid.rs
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! The `Txid` type.
+//!
+//! In order to print and parse txids enable the "hex" feature.
+
+#[cfg(not(feature = "hex"))]
+use core::fmt;
+#[cfg(feature = "hex")]
+use core::str;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use hashes::sha256d;
+
+/// A bitcoin witness transaction ID.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Wtxid(sha256d::Hash);
+
+impl Wtxid {
+    /// The `Wtxid` of a coinbase transaction.
+    ///
+    /// This is used as the wTXID for the coinbase transaction when constructing blocks (in the
+    /// witness commitment tree) since the coinbase transaction contains a commitment to all
+    /// transactions' wTXIDs but naturally cannot commit to its own.
+    pub const COINBASE: Self = Self::from_byte_array([0; 32]);
+}
+
+// The new hash wrapper type.
+type HashType = Wtxid;
+// The inner hash type from `hashes`.
+type Inner = sha256d::Hash;
+
+include!("./generic.rs");
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 2a22b6060f..7c2823166a 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -1,23 +1,24 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin - primitive types
+//! Rust Bitcoin - primitive types
 //!
 //! Primitive data types that are used throughout the [`rust-bitcoin`] ecosystem.
 //!
+//! If you are using `rust-bitcoin` then you do not need to access this crate directly. Everything
+//! here is re-exported in `rust-bitcoin` at the same path.
+//!
 //! This crate can be used in a no-std environment but a lot of the functionality requires an
 //! allocator i.e., requires the `alloc` feature to be enabled.
 //!
 //! [`rust-bitcoin`]: <https://github.com/rust-bitcoin>
 
-#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![no_std]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
-// Exclude lints we don't think are valuable.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+// Package-specific lint overrides.
+
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -29,6 +30,9 @@ extern crate std;
 #[macro_use]
 extern crate serde;
 
+#[cfg(feature = "hex")]
+pub extern crate hex_stable as hex;
+
 #[doc(hidden)]
 pub mod _export {
     /// A re-export of `core::*`.
@@ -37,14 +41,15 @@ pub mod _export {
     }
 }
 
+mod hash_types;
+#[cfg(feature = "alloc")]
+mod opcodes;
+
 pub mod block;
-pub mod locktime;
 pub mod merkle_tree;
-mod opcodes;
 pub mod pow;
 #[cfg(feature = "alloc")]
 pub mod script;
-pub mod sequence;
 pub mod transaction;
 #[cfg(feature = "alloc")]
 pub mod witness;
@@ -54,11 +59,15 @@ pub use units::{
     amount::{self, Amount, SignedAmount},
     block::{BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval},
     fee_rate::{self, FeeRate},
-    time::{self, BlockTime},
+    locktime::{self, absolute, relative},
+    parse_int,
+    result::{self, NumOpResult},
+    sequence::{self, Sequence},
+    time::{self, BlockTime, BlockTimeDecoder, BlockTimeDecoderError},
     weight::{self, Weight},
 };
 
-#[deprecated(since = "TBD", note = "use `BlockHeightInterval` instead")]
+#[deprecated(since = "1.0.0-rc.0", note = "use `BlockHeightInterval` instead")]
 #[doc(hidden)]
 pub type BlockInterval = BlockHeightInterval;
 
@@ -68,18 +77,19 @@ pub use self::{
     block::{
         Block, Checked as BlockChecked, Unchecked as BlockUnchecked, Validation as BlockValidation,
     },
-    script::{Script, ScriptBuf},
+    script::{
+        RedeemScript, RedeemScriptBuf, ScriptPubKey, ScriptPubKeyBuf, ScriptSig, ScriptSigBuf,
+        TapScript, TapScriptBuf, WitnessScript, WitnessScriptBuf,
+    },
     transaction::{Transaction, TxIn, TxOut},
     witness::Witness,
 };
 #[doc(inline)]
 pub use self::{
     block::{BlockHash, Header as BlockHeader, Version as BlockVersion, WitnessCommitment},
-    locktime::{absolute, relative},
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     pow::CompactTarget,
-    sequence::Sequence,
-    transaction::{OutPoint, Txid, Version as TransactionVersion, Wtxid},
+    transaction::{Ntxid, OutPoint, Txid, Version as TransactionVersion, Wtxid},
 };
 
 #[rustfmt::skip]
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
deleted file mode 100644
index 1bc5b5a78d..0000000000
--- a/primitives/src/locktime/absolute.rs
+++ /dev/null
@@ -1,561 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Provides type [`LockTime`] that implements the logic around `nLockTime`/`OP_CHECKLOCKTIMEVERIFY`.
-//!
-//! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
-//! whether `LockTime < LOCKTIME_THRESHOLD`.
-
-use core::fmt;
-
-#[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
-use units::parse::{self, PrefixedHexError, UnprefixedHexError};
-
-#[cfg(all(doc, feature = "alloc"))]
-use crate::{absolute, Transaction};
-
-#[rustfmt::skip]                // Keep public re-exports separate.
-#[doc(inline)]
-pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, ParseTimeError, MedianTimePast, LOCK_TIME_THRESHOLD};
-
-#[deprecated(since = "TBD", note = "use `MedianTimePast` instead")]
-#[doc(hidden)]
-pub type Time = MedianTimePast;
-
-/// An absolute lock time value, representing either a block height or a UNIX timestamp (seconds
-/// since epoch).
-///
-/// Used for transaction lock time (`nLockTime` in Bitcoin Core and [`Transaction::lock_time`]
-/// in this library) and also for the argument to opcode `OP_CHECKLOCKTIMEVERIFY`.
-///
-/// # Note on ordering
-///
-/// Locktimes may be height- or time-based, and these metrics are incommensurate; there is no total
-/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
-/// [`LockTime::is_satisfied_by`] API.
-///
-/// For [`Transaction`], which has a locktime field, we implement a total ordering to make
-/// it easy to store transactions in sorted data structures, and use the locktime's 32-bit integer
-/// consensus encoding to order it.
-///
-/// # Relevant BIPs
-///
-/// * [BIP-65 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
-/// * [BIP-113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
-///
-/// # Examples
-///
-/// ```
-/// use bitcoin_primitives::absolute::{self, LockTime as L};
-/// # let n = absolute::LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
-/// # let lock_time = absolute::LockTime::from_consensus(741521);  // nLockTime
-/// // To compare absolute lock times there are various `is_satisfied_*` methods, you may also use:
-/// let _is_satisfied = match (n, lock_time) {
-///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
-///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
-///     _ => panic!("handle invalid comparison error"),
-/// };
-/// ```
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub enum LockTime {
-    /// A block height lock time value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin_primitives::absolute;
-    ///
-    /// let block: u32 = 741521;
-    /// let n = absolute::LockTime::from_height(block).expect("valid height");
-    /// assert!(n.is_block_height());
-    /// assert_eq!(n.to_consensus_u32(), block);
-    /// ```
-    Blocks(Height),
-    /// A UNIX timestamp lock time value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin_primitives::absolute;
-    ///
-    /// let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
-    /// let n = absolute::LockTime::from_time(seconds).expect("valid time");
-    /// assert!(n.is_block_time());
-    /// assert_eq!(n.to_consensus_u32(), seconds);
-    /// ```
-    Seconds(MedianTimePast),
-}
-
-impl LockTime {
-    /// If [`Transaction::lock_time`] is set to zero it is ignored, in other words a
-    /// transaction with nLocktime==0 is able to be included immediately in any block.
-    pub const ZERO: LockTime = LockTime::Blocks(Height::ZERO);
-
-    /// The number of bytes that the locktime contributes to the size of a transaction.
-    pub const SIZE: usize = 4; // Serialized length of a u32.
-
-    /// Constructs a new `LockTime` from a prefixed hex string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_primitives::absolute;
-    /// let hex_str = "0x61cf9980"; // Unix timestamp for January 1, 2022
-    /// let lock_time = absolute::LockTime::from_hex(hex_str)?;
-    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
-    ///
-    /// # Ok::<_, units::parse::PrefixedHexError>(())
-    /// ```
-    #[inline]
-    pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
-        let lock_time = parse::hex_u32_prefixed(s)?;
-        Ok(Self::from_consensus(lock_time))
-    }
-
-    /// Constructs a new `LockTime` from an unprefixed hex string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_primitives::absolute;
-    /// let hex_str = "61cf9980"; // Unix timestamp for January 1, 2022
-    /// let lock_time = absolute::LockTime::from_unprefixed_hex(hex_str)?;
-    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
-    ///
-    /// # Ok::<_, units::parse::UnprefixedHexError>(())
-    /// ```
-    #[inline]
-    pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
-        let lock_time = parse::hex_u32_unprefixed(s)?;
-        Ok(Self::from_consensus(lock_time))
-    }
-
-    /// Constructs a new `LockTime` from an `nLockTime` value or the argument to `OP_CHEKCLOCKTIMEVERIFY`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::absolute;
-    ///
-    /// // `from_consensus` roundtrips as expected with `to_consensus_u32`.
-    /// let n_lock_time: u32 = 741521;
-    /// let lock_time = absolute::LockTime::from_consensus(n_lock_time);
-    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
-    #[inline]
-    #[allow(clippy::missing_panics_doc)]
-    pub fn from_consensus(n: u32) -> Self {
-        if units::locktime::absolute::is_block_height(n) {
-            Self::Blocks(Height::from_u32(n).expect("n is valid"))
-        } else {
-            Self::Seconds(MedianTimePast::from_u32(n).expect("n is valid"))
-        }
-    }
-
-    /// Constructs a new `LockTime` from `n`, expecting `n` to be a valid block height.
-    ///
-    /// # Note
-    ///
-    /// If the current block height is `h` and the locktime is set to `h`,
-    /// the transaction can be included in block `h+1` or later.
-    /// It is possible to broadcast the transaction at block height `h`.
-    ///
-    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid height value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::absolute;
-    /// assert!(absolute::LockTime::from_height(741521).is_ok());
-    /// assert!(absolute::LockTime::from_height(1653195600).is_err());
-    /// ```
-    #[inline]
-    pub fn from_height(n: u32) -> Result<Self, ConversionError> {
-        let height = Height::from_u32(n)?;
-        Ok(LockTime::Blocks(height))
-    }
-
-    #[inline]
-    #[deprecated(since = "TBD", note = "use `from_mtp` instead")]
-    #[doc(hidden)]
-    pub fn from_time(n: u32) -> Result<Self, ConversionError> { Self::from_mtp(n) }
-
-    /// Constructs a new `LockTime` from `n`, expecting `n` to be a median-time-past (MTP)
-    /// which is in range for a locktime.
-    ///
-    /// # Note
-    ///
-    /// If the locktime is set to an MTP `T`, the transaction can be included in a block only if
-    /// the MTP of last recent 11 blocks is greater than `T`.
-    ///
-    /// It is possible to broadcast the transaction once the MTP is greater than `T`. See BIP-113.
-    ///
-    /// [BIP-113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
-    ///
-    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid time value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::absolute;
-    /// assert!(absolute::LockTime::from_time(1653195600).is_ok());
-    /// assert!(absolute::LockTime::from_time(741521).is_err());
-    /// ```
-    #[inline]
-    pub fn from_mtp(n: u32) -> Result<Self, ConversionError> {
-        let time = MedianTimePast::from_u32(n)?;
-        Ok(LockTime::Seconds(time))
-    }
-
-    /// Returns true if both lock times use the same unit i.e., both height based or both time based.
-    #[inline]
-    pub const fn is_same_unit(self, other: LockTime) -> bool {
-        matches!(
-            (self, other),
-            (LockTime::Blocks(_), LockTime::Blocks(_))
-                | (LockTime::Seconds(_), LockTime::Seconds(_))
-        )
-    }
-
-    /// Returns true if this lock time value is a block height.
-    #[inline]
-    pub const fn is_block_height(self) -> bool { matches!(self, LockTime::Blocks(_)) }
-
-    /// Returns true if this lock time value is a block time (UNIX timestamp).
-    #[inline]
-    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
-
-    /// Returns true if this timelock constraint is satisfied by the respective `height`/`time`.
-    ///
-    /// If `self` is a blockheight based lock then it is checked against `height` and if `self` is a
-    /// blocktime based lock it is checked against `time`.
-    ///
-    /// A 'timelock constraint' refers to the `n` from `n OP_CHEKCLOCKTIMEVERIFY`, this constraint
-    /// is satisfied if a transaction with `nLockTime` ([`Transaction::lock_time`]) set to
-    /// `height`/`time` is valid.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use bitcoin_primitives::absolute;
-    /// // Can be implemented if block chain data is available.
-    /// fn get_height() -> absolute::Height { todo!("return the current block height") }
-    /// fn get_time() -> absolute::MedianTimePast { todo!("return the current block time") }
-    ///
-    /// let n = absolute::LockTime::from_consensus(741521); // `n OP_CHEKCLOCKTIMEVERIFY`.
-    /// if n.is_satisfied_by(get_height(), get_time()) {
-    ///     // Can create and mine a transaction that satisfies the OP_CLTV timelock constraint.
-    /// }
-    /// ````
-    #[inline]
-    pub fn is_satisfied_by(self, height: Height, time: MedianTimePast) -> bool {
-        use LockTime as L;
-
-        match self {
-            L::Blocks(n) => n <= height,
-            L::Seconds(n) => n <= time,
-        }
-    }
-
-    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
-    /// [`absolute::LockTime`].
-    ///
-    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
-    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
-    /// mathematical sense) the smaller one being satisfied.
-    ///
-    /// This function serves multiple purposes:
-    ///
-    /// * When evaluating `OP_CHECKLOCKTIMEVERIFY` the argument must be less than or equal to the
-    ///   transactions nLockTime. If using this function to validate a script `self` is the argument
-    ///   to `CLTV` and `other` is the transaction nLockTime.
-    ///
-    /// * If you wish to check a lock time against various other locks e.g., filtering out locks
-    ///   which cannot be satisfied. Can also be used to remove the smaller value of two
-    ///   `OP_CHECKLOCKTIMEVERIFY` operations within one branch of the script.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::absolute;
-    /// let lock_time = absolute::LockTime::from_consensus(741521);
-    /// let check = absolute::LockTime::from_consensus(741521 + 1);
-    /// assert!(lock_time.is_implied_by(check));
-    /// ```
-    #[inline]
-    pub fn is_implied_by(self, other: LockTime) -> bool {
-        use LockTime as L;
-
-        match (self, other) {
-            (L::Blocks(this), L::Blocks(other)) => this <= other,
-            (L::Seconds(this), L::Seconds(other)) => this <= other,
-            _ => false, // Not the same units.
-        }
-    }
-
-    /// Returns the inner `u32` value. This is the value used when creating this `LockTime`
-    /// i.e., `n OP_CHECKLOCKTIMEVERIFY` or `nLockTime`.
-    ///
-    /// # Warning
-    ///
-    /// Do not compare values return by this method. The whole point of the `LockTime` type is to
-    /// assist in doing correct comparisons. Either use `is_satisfied_by`, `is_satisfied_by_lock`,
-    /// or use the pattern below:
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin_primitives::absolute::{self, LockTime as L};
-    /// # let n = absolute::LockTime::from_consensus(741521);  // n OP_CHECKLOCKTIMEVERIFY
-    /// # let lock_time = absolute::LockTime::from_consensus(741521 + 1);  // nLockTime
-    ///
-    /// let _is_satisfied = match (n, lock_time) {
-    ///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
-    ///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
-    ///     _ => panic!("invalid comparison"),
-    /// };
-    ///
-    /// // Or, if you have Rust 1.53 or greater
-    /// // let is_satisfied = n.partial_cmp(&lock_time).expect("invalid comparison").is_le();
-    /// ```
-    #[inline]
-    pub fn to_consensus_u32(self) -> u32 {
-        match self {
-            LockTime::Blocks(ref h) => h.to_u32(),
-            LockTime::Seconds(ref t) => t.to_u32(),
-        }
-    }
-}
-
-units::impl_parse_str_from_int_infallible!(LockTime, u32, from_consensus);
-
-impl From<Height> for LockTime {
-    #[inline]
-    fn from(h: Height) -> Self { LockTime::Blocks(h) }
-}
-
-impl From<MedianTimePast> for LockTime {
-    #[inline]
-    fn from(t: MedianTimePast) -> Self { LockTime::Seconds(t) }
-}
-
-impl fmt::Debug for LockTime {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime as L;
-
-        match *self {
-            L::Blocks(ref h) => write!(f, "{} blocks", h),
-            L::Seconds(ref t) => write!(f, "{} seconds", t),
-        }
-    }
-}
-
-impl fmt::Display for LockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime as L;
-
-        if f.alternate() {
-            match *self {
-                L::Blocks(ref h) => write!(f, "block-height {}", h),
-                L::Seconds(ref t) => write!(f, "block-time {} (seconds since epoch)", t),
-            }
-        } else {
-            match *self {
-                L::Blocks(ref h) => fmt::Display::fmt(h, f),
-                L::Seconds(ref t) => fmt::Display::fmt(t, f),
-            }
-        }
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for LockTime {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_u32(self.to_consensus_u32())
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for LockTime {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct Visitor;
-        impl serde::de::Visitor<'_> for Visitor {
-            type Value = u32;
-            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("a u32") }
-            // We cannot just implement visit_u32 because JSON (among other things) always
-            // calls visit_u64, even when called from Deserializer::deserialize_u32. The
-            // other visit_u*s have default implementations that forward to visit_u64.
-            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<u32, E> {
-                v.try_into().map_err(|_| {
-                    E::invalid_value(serde::de::Unexpected::Unsigned(v), &"a 32-bit number")
-                })
-            }
-            // Also do the signed version, just for good measure.
-            fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<u32, E> {
-                v.try_into().map_err(|_| {
-                    E::invalid_value(serde::de::Unexpected::Signed(v), &"a 32-bit number")
-                })
-            }
-        }
-        deserializer.deserialize_u32(Visitor).map(LockTime::from_consensus)
-    }
-}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for LockTime {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let l = u32::arbitrary(u)?;
-        Ok(LockTime::from_consensus(l))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn display_and_alternate() {
-        let lock_by_height = LockTime::from_height(741_521).unwrap();
-        let lock_by_time = LockTime::from_mtp(1_653_195_600).unwrap(); // May 22nd 2022, 5am UTC.
-
-        assert_eq!(format!("{}", lock_by_height), "741521");
-        assert_eq!(format!("{:#}", lock_by_height), "block-height 741521");
-        assert!(!format!("{:?}", lock_by_height).is_empty());
-
-        assert_eq!(format!("{}", lock_by_time), "1653195600");
-        assert_eq!(format!("{:#}", lock_by_time), "block-time 1653195600 (seconds since epoch)");
-        assert!(!format!("{:?}", lock_by_time).is_empty());
-    }
-
-    #[test]
-    fn roundtrips() {
-        let lock_by_height = LockTime::from_consensus(741_521);
-        let lock_by_time = LockTime::from_consensus(1_653_195_600);
-
-        assert_eq!(lock_by_height.to_consensus_u32(), 741_521);
-        assert_eq!(lock_by_time.to_consensus_u32(), 1_653_195_600);
-    }
-
-    #[test]
-    fn lock_time_from_hex_lower() {
-        let lock_by_time = LockTime::from_hex("0x6289c350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
-    }
-
-    #[test]
-    fn lock_time_from_hex_upper() {
-        let lock_by_time = LockTime::from_hex("0X6289C350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
-    }
-
-    #[test]
-    fn lock_time_from_unprefixed_hex_lower() {
-        let lock_by_time = LockTime::from_unprefixed_hex("6289c350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
-    }
-
-    #[test]
-    fn lock_time_from_unprefixed_hex_upper() {
-        let lock_by_time = LockTime::from_unprefixed_hex("6289C350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
-    }
-
-    #[test]
-    fn invalid_hex() {
-        assert!(LockTime::from_hex("0xzb93").is_err());
-        assert!(LockTime::from_unprefixed_hex("zb93").is_err());
-    }
-
-    #[test]
-    fn invalid_locktime_type() {
-        assert!(LockTime::from_height(499_999_999).is_ok()); // Below the threshold.
-        assert!(LockTime::from_height(500_000_000).is_err()); // The threshold.
-        assert!(LockTime::from_height(500_000_001).is_err()); // Above the threshold.
-
-        assert!(LockTime::from_mtp(499_999_999).is_err()); // Below the threshold.
-        assert!(LockTime::from_mtp(500_000_000).is_ok()); // The threshold.
-        assert!(LockTime::from_mtp(500_000_001).is_ok()); // Above the threshold.
-    }
-
-    #[test]
-    fn parses_correctly_to_height_or_time() {
-        let lock_by_height = LockTime::from_consensus(750_000);
-
-        assert!(lock_by_height.is_block_height());
-        assert!(!lock_by_height.is_block_time());
-
-        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
-        let lock_by_time = LockTime::from_consensus(t);
-
-        assert!(!lock_by_time.is_block_height());
-        assert!(lock_by_time.is_block_time());
-
-        // Test is_same_unit() logic
-        assert!(lock_by_height.is_same_unit(LockTime::from_consensus(800_000)));
-        assert!(!lock_by_height.is_same_unit(lock_by_time));
-        assert!(lock_by_time.is_same_unit(LockTime::from_consensus(1_653_282_000)));
-        assert!(!lock_by_time.is_same_unit(lock_by_height));
-    }
-
-    #[test]
-    fn satisfied_by_height() {
-        let height_below = Height::from_u32(700_000).unwrap();
-        let height = Height::from_u32(750_000).unwrap();
-        let height_above = Height::from_u32(800_000).unwrap();
-
-        let lock_by_height = LockTime::from(height);
-
-        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
-        let time = MedianTimePast::from_u32(t).unwrap();
-
-        assert!(!lock_by_height.is_satisfied_by(height_below, time));
-        assert!(lock_by_height.is_satisfied_by(height, time));
-        assert!(lock_by_height.is_satisfied_by(height_above, time));
-    }
-
-    #[test]
-    fn satisfied_by_time() {
-        let time_before = MedianTimePast::from_u32(1_653_109_200).unwrap(); // "May 21th 2022, 5am UTC.
-        let time = MedianTimePast::from_u32(1_653_195_600).unwrap(); // "May 22nd 2022, 5am UTC.
-        let time_after = MedianTimePast::from_u32(1_653_282_000).unwrap(); // "May 23rd 2022, 5am UTC.
-
-        let lock_by_time = LockTime::from(time);
-
-        let height = Height::from_u32(800_000).unwrap();
-
-        assert!(!lock_by_time.is_satisfied_by(height, time_before));
-        assert!(lock_by_time.is_satisfied_by(height, time));
-        assert!(lock_by_time.is_satisfied_by(height, time_after));
-    }
-
-    #[test]
-    fn height_correctly_implies() {
-        let lock_by_height = LockTime::from_consensus(750_005);
-
-        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(750_004)));
-        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_005)));
-        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_006)));
-    }
-
-    #[test]
-    fn time_correctly_implies() {
-        let t: u32 = 1_700_000_005;
-        let lock_by_time = LockTime::from_consensus(t);
-
-        assert!(!lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_004)));
-        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_005)));
-        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_006)));
-    }
-
-    #[test]
-    fn incorrect_units_do_not_imply() {
-        let lock_by_height = LockTime::from_consensus(750_005);
-        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(1_700_000_004)));
-    }
-}
diff --git a/primitives/src/locktime/mod.rs b/primitives/src/locktime/mod.rs
deleted file mode 100644
index 4cf62ad101..0000000000
--- a/primitives/src/locktime/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Provides absolute and relative locktimes.
-
-pub mod absolute;
-pub mod relative;
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
deleted file mode 100644
index 2c9668d1c5..0000000000
--- a/primitives/src/locktime/relative.rs
+++ /dev/null
@@ -1,753 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Provides type [`LockTime`] that implements the logic around `nSequence`/`OP_CHECKSEQUENCEVERIFY`.
-//!
-//! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
-//! whether bit 22 of the `u32` consensus value is set.
-
-use core::{convert, fmt};
-
-use crate::Sequence;
-#[cfg(all(doc, feature = "alloc"))]
-use crate::{relative, TxIn};
-
-#[rustfmt::skip]                // Keep public re-exports separate.
-#[doc(inline)]
-pub use units::locktime::relative::{NumberOfBlocks, NumberOf512Seconds, TimeOverflowError};
-use units::{BlockHeight, BlockMtp};
-
-#[deprecated(since = "TBD", note = "use `NumberOfBlocks` instead")]
-#[doc(hidden)]
-pub type Height = NumberOfBlocks;
-
-#[deprecated(since = "TBD", note = "use `NumberOf512Seconds` instead")]
-#[doc(hidden)]
-pub type Time = NumberOf512Seconds;
-
-/// A relative lock time value, representing either a block height or time (512 second intervals).
-///
-/// Used for sequence numbers (`nSequence` in Bitcoin Core and [`TxIn::sequence`]
-/// in this library) and also for the argument to opcode `OP_CHECKSEQUENCEVERIFY`.
-///
-/// # Note on ordering
-///
-/// Locktimes may be height- or time-based, and these metrics are incommensurate; there is no total
-/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
-/// [`LockTime::is_satisfied_by`] API.
-///
-/// # Relevant BIPs
-///
-/// * [BIP 68 Relative lock-time using consensus-enforced sequence numbers](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
-/// * [BIP 112 CHECKSEQUENCEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki)
-///
-/// # Examples
-///
-/// ```
-/// use bitcoin_primitives::relative;
-/// use bitcoin_primitives::{BlockHeight, BlockMtp, BlockTime};
-/// let lock_by_height = relative::LockTime::from_height(144); // 144 blocks, approx 24h.
-/// assert!(lock_by_height.is_block_height());
-///
-/// let lock_by_time = relative::LockTime::from_512_second_intervals(168); // 168 time intervals, approx 24h.
-/// assert!(lock_by_time.is_block_time());
-///
-/// fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
-///     let mut timestamps = [BlockTime::from_u32(0); 11];
-///     for (i, ts) in timestamps.iter_mut().enumerate() {
-///         *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
-///     }
-///     timestamps
-/// }
-/// // time extracted from BlockHeader
-/// let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
-/// let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
-///
-/// let current_height = BlockHeight::from(100);
-/// let current_mtp = BlockMtp::new(timestamps);
-///
-/// let utxo_height = BlockHeight::from(80);
-/// let utxo_mtp = BlockMtp::new(utxo_timestamps);
-///
-/// let locktime = relative::LockTime::Time(relative::NumberOf512Seconds::from_512_second_intervals(10));
-///
-/// // Check if locktime is satisfied
-/// assert!(locktime.is_satisfied_by(current_height, current_mtp, utxo_height, utxo_mtp));
-/// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum LockTime {
-    /// A block height lock time value.
-    Blocks(NumberOfBlocks),
-    /// A 512 second time interval value.
-    Time(NumberOf512Seconds),
-}
-
-impl LockTime {
-    /// A relative locktime of 0 is always valid, and is assumed valid for inputs that
-    /// are not yet confirmed.
-    pub const ZERO: LockTime = LockTime::Blocks(NumberOfBlocks::ZERO);
-
-    /// The number of bytes that the locktime contributes to the size of a transaction.
-    pub const SIZE: usize = 4; // Serialized length of a u32.
-
-    /// Constructs a new `LockTime` from an `nSequence` value or the argument to `OP_CHECKSEQUENCEVERIFY`.
-    ///
-    /// This method will **not** round-trip with [`Self::to_consensus_u32`], because relative
-    /// locktimes only use some bits of the underlying `u32` value and discard the rest. If
-    /// you want to preserve the full value, you should use the [`Sequence`] type instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::relative;
-    ///
-    /// // Values with bit 22 set to 0 will be interpreted as height-based lock times.
-    /// let height: u32 = 144; // 144 blocks, approx 24h.
-    /// let lock_time = relative::LockTime::from_consensus(height)?;
-    /// assert!(lock_time.is_block_height());
-    /// assert_eq!(lock_time.to_consensus_u32(), height);
-    ///
-    /// // Values with bit 22 set to 1 will be interpreted as time-based lock times.
-    /// let time: u32 = 168 | (1 << 22) ; // Bit 22 is 1 with time approx 24h.
-    /// let lock_time = relative::LockTime::from_consensus(time)?;
-    /// assert!(lock_time.is_block_time());
-    /// assert_eq!(lock_time.to_consensus_u32(), time);
-    ///
-    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
-    /// ```
-    #[inline]
-    pub fn from_consensus(n: u32) -> Result<Self, DisabledLockTimeError> {
-        let sequence = crate::Sequence::from_consensus(n);
-        sequence.to_relative_lock_time().ok_or(DisabledLockTimeError(n))
-    }
-
-    /// Returns the `u32` value used to encode this locktime in an `nSequence` field or
-    /// argument to `OP_CHECKSEQUENCEVERIFY`.
-    ///
-    /// # Warning
-    ///
-    /// Locktimes are not ordered by the natural ordering on `u32`. If you want to
-    /// compare locktimes, use [`Self::is_implied_by`] or similar methods.
-    #[inline]
-    pub fn to_consensus_u32(self) -> u32 {
-        match self {
-            LockTime::Blocks(ref h) => u32::from(h.to_height()),
-            LockTime::Time(ref t) =>
-                Sequence::LOCK_TYPE_MASK | u32::from(t.to_512_second_intervals()),
-        }
-    }
-
-    /// Constructs a new `LockTime` from the sequence number of a Bitcoin input.
-    ///
-    /// This method will **not** round-trip with [`Self::to_sequence`]. See the
-    /// docs for [`Self::from_consensus`] for more information.
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::{Sequence, relative};
-    ///
-    /// // Interpret a sequence number from a Bitcoin transaction input as a relative lock time
-    /// let sequence_number = Sequence::from_consensus(144); // 144 blocks, approx 24h.
-    /// let lock_time = relative::LockTime::from_sequence(sequence_number)?;
-    /// assert!(lock_time.is_block_height());
-    ///
-    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
-    /// ```
-    #[inline]
-    pub fn from_sequence(n: Sequence) -> Result<Self, DisabledLockTimeError> {
-        Self::from_consensus(n.to_consensus_u32())
-    }
-
-    /// Encodes the locktime as a sequence number.
-    #[inline]
-    pub fn to_sequence(self) -> Sequence { Sequence::from_consensus(self.to_consensus_u32()) }
-
-    /// Constructs a new `LockTime` from `n`, expecting `n` to be a 16-bit count of blocks.
-    #[inline]
-    pub const fn from_height(n: u16) -> Self { LockTime::Blocks(NumberOfBlocks::from_height(n)) }
-
-    /// Constructs a new `LockTime` from `n`, expecting `n` to be a count of 512-second intervals.
-    ///
-    /// This function is a little awkward to use, and users may wish to instead use
-    /// [`Self::from_seconds_floor`] or [`Self::from_seconds_ceil`].
-    #[inline]
-    pub const fn from_512_second_intervals(intervals: u16) -> Self {
-        LockTime::Time(NumberOf512Seconds::from_512_second_intervals(intervals))
-    }
-
-    /// Construct a new [`LockTime`] from seconds, converting the seconds into 512 second interval
-    /// with truncating division.
-    ///
-    /// # Errors
-    ///
-    /// Will return an error if the input cannot be encoded in 16 bits.
-    #[inline]
-    pub const fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
-        match NumberOf512Seconds::from_seconds_floor(seconds) {
-            Ok(time) => Ok(LockTime::Time(time)),
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Construct a new [`LockTime`] from seconds, converting the seconds into 512 second interval
-    /// with ceiling division.
-    ///
-    /// # Errors
-    ///
-    /// Will return an error if the input cannot be encoded in 16 bits.
-    #[inline]
-    pub const fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
-        match NumberOf512Seconds::from_seconds_ceil(seconds) {
-            Ok(time) => Ok(LockTime::Time(time)),
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Returns true if both lock times use the same unit i.e., both height based or both time based.
-    #[inline]
-    pub const fn is_same_unit(self, other: LockTime) -> bool {
-        matches!(
-            (self, other),
-            (LockTime::Blocks(_), LockTime::Blocks(_)) | (LockTime::Time(_), LockTime::Time(_))
-        )
-    }
-
-    /// Returns true if this lock time value is in units of block height.
-    #[inline]
-    pub const fn is_block_height(self) -> bool { matches!(self, LockTime::Blocks(_)) }
-
-    /// Returns true if this lock time value is in units of time.
-    #[inline]
-    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
-
-    /// Returns true if this [`relative::LockTime`] is satisfied by the given chain state.
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::relative::Time;
-    /// # use bitcoin_primitives::{BlockHeight, BlockMtp, BlockTime};
-    /// # use bitcoin_primitives::relative::LockTime;
-    ///
-    /// fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
-    ///     let mut timestamps = [BlockTime::from_u32(0); 11];
-    ///     for (i, ts) in timestamps.iter_mut().enumerate() {
-    ///         *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
-    ///     }
-    ///     timestamps
-    /// }
-    /// // time extracted from BlockHeader
-    /// let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
-    /// let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
-    ///
-    /// let current_height = BlockHeight::from_u32(100);
-    /// let current_mtp = BlockMtp::new(timestamps);
-    /// let utxo_height = BlockHeight::from_u32(80);
-    /// let utxo_mtp = BlockMtp::new(utxo_timestamps);
-    ///
-    /// let locktime = LockTime::Time(Time::from_512_second_intervals(10));
-    ///
-    /// // Check if locktime is satisfied
-    /// assert!(locktime.is_satisfied_by(current_height, current_mtp, utxo_height, utxo_mtp));
-    /// ```
-    pub fn is_satisfied_by(
-        self,
-        chain_tip_height: BlockHeight,
-        chain_tip_mtp: BlockMtp,
-        utxo_mined_at_height: BlockHeight,
-        utxo_mined_at_mtp: BlockMtp,
-    ) -> bool {
-        match self {
-            LockTime::Blocks(blocks) =>
-                blocks.is_satisfied_by(chain_tip_height, utxo_mined_at_height),
-            LockTime::Time(time) => time.is_satisfied_by(chain_tip_mtp, utxo_mined_at_mtp),
-        }
-    }
-
-    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
-    /// [`relative::LockTime`].
-    ///
-    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
-    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
-    /// mathematical sense) the smaller one being satisfied.
-    ///
-    /// This function is useful when checking sequence values against a lock, first one checks the
-    /// sequence represents a relative lock time by converting to `LockTime` then use this function
-    /// to see if satisfaction of the newly created lock time would imply satisfaction of `self`.
-    ///
-    /// Can also be used to remove the smaller value of two `OP_CHECKSEQUENCEVERIFY` operations
-    /// within one branch of the script.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::Sequence;
-    ///
-    /// # let required_height = 100;       // 100 blocks.
-    /// # let lock = Sequence::from_height(required_height).to_relative_lock_time().expect("valid height");
-    /// # let test_sequence = Sequence::from_height(required_height + 10);
-    ///
-    /// let satisfied = match test_sequence.to_relative_lock_time() {
-    ///     None => false, // Handle non-lock-time case.
-    ///     Some(test_lock) => lock.is_implied_by(test_lock),
-    /// };
-    /// assert!(satisfied);
-    /// ```
-    #[inline]
-    pub fn is_implied_by(self, other: LockTime) -> bool {
-        use LockTime as L;
-
-        match (self, other) {
-            (L::Blocks(this), L::Blocks(other)) => this <= other,
-            (L::Time(this), L::Time(other)) => this <= other,
-            _ => false, // Not the same units.
-        }
-    }
-
-    /// Returns true if satisfaction of the sequence number implies satisfaction of this lock time.
-    ///
-    /// When deciding whether an instance of `<n> CHECKSEQUENCEVERIFY` will pass, this
-    /// method can be used by parsing `n` as a [`LockTime`] and calling this method
-    /// with the sequence number of the input which spends the script.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_primitives::{Sequence, relative};
-    ///
-    /// let sequence = Sequence::from_consensus(1 << 22 | 168); // Bit 22 is 1 with time approx 24h.
-    /// let lock_time = relative::LockTime::from_sequence(sequence)?;
-    /// let input_sequence = Sequence::from_consensus(1 << 22 | 336); // Approx 48h.
-    /// assert!(lock_time.is_block_time());
-    ///
-    /// assert!(lock_time.is_implied_by_sequence(input_sequence));
-    ///
-    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
-    /// ```
-    #[inline]
-    pub fn is_implied_by_sequence(self, other: Sequence) -> bool {
-        if let Ok(other) = LockTime::from_sequence(other) {
-            self.is_implied_by(other)
-        } else {
-            false
-        }
-    }
-
-    /// Returns true if this [`relative::LockTime`] is satisfied by [`NumberOfBlocks`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this lock is not lock-by-height.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::Sequence;
-    /// # use bitcoin_primitives::relative;
-    ///
-    /// let required_height: u16 = 100;
-    /// let lock = Sequence::from_height(required_height).to_relative_lock_time().expect("valid height");
-    /// assert!(lock.is_satisfied_by_height(relative::NumberOfBlocks::from(required_height + 1)).expect("a height"));
-    /// ```
-    #[inline]
-    pub fn is_satisfied_by_height(
-        self,
-        height: NumberOfBlocks,
-    ) -> Result<bool, IncompatibleHeightError> {
-        use LockTime as L;
-
-        match self {
-            L::Blocks(required_height) => Ok(required_height <= height),
-            L::Time(time) => Err(IncompatibleHeightError { height, time }),
-        }
-    }
-
-    /// Returns true if this [`relative::LockTime`] is satisfied by [`Time`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this lock is not lock-by-time.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use bitcoin_primitives::Sequence;
-    /// # use bitcoin_primitives::relative;
-    ///
-    /// let intervals: u16 = 70; // approx 10 hours;
-    /// let lock = Sequence::from_512_second_intervals(intervals).to_relative_lock_time().expect("valid time");
-    /// assert!(lock.is_satisfied_by_time(relative::Time::from_512_second_intervals(intervals + 10)).expect("a time"));
-    /// ```
-    #[inline]
-    pub fn is_satisfied_by_time(
-        self,
-        time: NumberOf512Seconds,
-    ) -> Result<bool, IncompatibleTimeError> {
-        use LockTime as L;
-
-        match self {
-            L::Time(ref t) => Ok(t.to_512_second_intervals() <= time.to_512_second_intervals()),
-            L::Blocks(height) => Err(IncompatibleTimeError { time, height }),
-        }
-    }
-}
-
-impl From<NumberOfBlocks> for LockTime {
-    #[inline]
-    fn from(h: NumberOfBlocks) -> Self { LockTime::Blocks(h) }
-}
-
-impl From<NumberOf512Seconds> for LockTime {
-    #[inline]
-    fn from(t: NumberOf512Seconds) -> Self { LockTime::Time(t) }
-}
-
-impl fmt::Display for LockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime as L;
-
-        if f.alternate() {
-            match *self {
-                L::Blocks(ref h) => write!(f, "block-height {}", h),
-                L::Time(ref t) => write!(f, "block-time {} (512 second intervals)", t),
-            }
-        } else {
-            match *self {
-                L::Blocks(ref h) => fmt::Display::fmt(h, f),
-                L::Time(ref t) => fmt::Display::fmt(t, f),
-            }
-        }
-    }
-}
-
-impl convert::TryFrom<Sequence> for LockTime {
-    type Error = DisabledLockTimeError;
-    #[inline]
-    fn try_from(seq: Sequence) -> Result<LockTime, DisabledLockTimeError> {
-        LockTime::from_sequence(seq)
-    }
-}
-
-impl From<LockTime> for Sequence {
-    #[inline]
-    fn from(lt: LockTime) -> Sequence { lt.to_sequence() }
-}
-
-/// Error returned when a sequence number is parsed as a lock time, but its
-/// "disable" flag is set.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct DisabledLockTimeError(u32);
-
-impl DisabledLockTimeError {
-    /// Accessor for the `u32` whose "disable" flag was set, preventing
-    /// it from being parsed as a relative locktime.
-    #[inline]
-    pub fn disabled_locktime_value(&self) -> u32 { self.0 }
-}
-
-impl fmt::Display for DisabledLockTimeError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "lock time 0x{:08x} has disable flag set", self.0)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for DisabledLockTimeError {}
-
-/// Tried to satisfy a lock-by-blocktime lock using a height value.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IncompatibleHeightError {
-    /// Attempted to satisfy a lock-by-blocktime lock with this height.
-    height: NumberOfBlocks,
-    /// The inner time value of the lock-by-blocktime lock.
-    time: NumberOf512Seconds,
-}
-
-impl IncompatibleHeightError {
-    /// Returns the height that was erroneously used to try and satisfy a lock-by-blocktime lock.
-    pub fn incompatible(&self) -> NumberOfBlocks { self.height }
-
-    /// Returns the time value of the lock-by-blocktime lock.
-    pub fn expected(&self) -> NumberOf512Seconds { self.time }
-}
-
-impl fmt::Display for IncompatibleHeightError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "tried to satisfy a lock-by-blocktime lock {} with height: {}",
-            self.time, self.height
-        )
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for IncompatibleHeightError {}
-
-/// Tried to satisfy a lock-by-blockheight lock using a time value.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IncompatibleTimeError {
-    /// Attempted to satisfy a lock-by-blockheight lock with this time.
-    time: NumberOf512Seconds,
-    /// The inner height value of the lock-by-blockheight lock.
-    height: NumberOfBlocks,
-}
-
-impl IncompatibleTimeError {
-    /// Returns the time that was erroneously used to try and satisfy a lock-by-blockheight lock.
-    pub fn incompatible(&self) -> NumberOf512Seconds { self.time }
-
-    /// Returns the height value of the lock-by-blockheight lock.
-    pub fn expected(&self) -> NumberOfBlocks { self.height }
-}
-
-impl fmt::Display for IncompatibleTimeError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "tried to satisfy a lock-by-blockheight lock {} with time: {}",
-            self.height, self.time
-        )
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for IncompatibleTimeError {}
-
-#[cfg(test)]
-mod tests {
-    use units::{BlockHeight, BlockTime};
-
-    use super::*;
-
-    #[test]
-    fn display_and_alternate() {
-        let lock_by_height = LockTime::from_height(10);
-        let lock_by_time = LockTime::from_512_second_intervals(70);
-
-        assert_eq!(format!("{}", lock_by_height), "10");
-        assert_eq!(format!("{:#}", lock_by_height), "block-height 10");
-        assert!(!format!("{:?}", lock_by_height).is_empty());
-
-        assert_eq!(format!("{}", lock_by_time), "70");
-        assert_eq!(format!("{:#}", lock_by_time), "block-time 70 (512 second intervals)");
-        assert!(!format!("{:?}", lock_by_time).is_empty());
-    }
-
-    #[test]
-    fn from_seconds_ceil_and_floor() {
-        let time = 70 * 512 + 1;
-        let lock_by_time = LockTime::from_seconds_ceil(time).unwrap();
-        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(71));
-
-        let lock_by_time = LockTime::from_seconds_floor(time).unwrap();
-        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(70));
-
-        let mut max_time = 0xffff * 512;
-        assert_eq!(LockTime::from_seconds_ceil(max_time), LockTime::from_seconds_floor(max_time));
-        max_time += 512;
-        assert!(LockTime::from_seconds_ceil(max_time).is_err());
-        assert!(LockTime::from_seconds_floor(max_time).is_err());
-    }
-
-    #[test]
-    fn parses_correctly_to_height_or_time() {
-        let height1 = NumberOfBlocks::from(10);
-        let height2 = NumberOfBlocks::from(11);
-        let time1 = NumberOf512Seconds::from_512_second_intervals(70);
-        let time2 = NumberOf512Seconds::from_512_second_intervals(71);
-
-        let lock_by_height1 = LockTime::from(height1);
-        let lock_by_height2 = LockTime::from(height2);
-        let lock_by_time1 = LockTime::from(time1);
-        let lock_by_time2 = LockTime::from(time2);
-
-        assert!(lock_by_height1.is_block_height());
-        assert!(!lock_by_height1.is_block_time());
-
-        assert!(!lock_by_time1.is_block_height());
-        assert!(lock_by_time1.is_block_time());
-
-        // Test is_same_unit() logic
-        assert!(lock_by_height1.is_same_unit(lock_by_height2));
-        assert!(!lock_by_height1.is_same_unit(lock_by_time1));
-        assert!(lock_by_time1.is_same_unit(lock_by_time2));
-        assert!(!lock_by_time1.is_same_unit(lock_by_height1));
-    }
-
-    #[test]
-    fn height_correctly_implies() {
-        let height = NumberOfBlocks::from(10);
-        let lock_by_height = LockTime::from(height);
-
-        assert!(!lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(9))));
-        assert!(lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(10))));
-        assert!(lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(11))));
-    }
-
-    #[test]
-    fn time_correctly_implies() {
-        let time = NumberOf512Seconds::from_512_second_intervals(70);
-        let lock_by_time = LockTime::from(time);
-
-        assert!(!lock_by_time
-            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(69))));
-        assert!(lock_by_time
-            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(70))));
-        assert!(lock_by_time
-            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(71))));
-    }
-
-    #[test]
-    fn sequence_correctly_implies() {
-        let height = NumberOfBlocks::from(10);
-        let time = NumberOf512Seconds::from_512_second_intervals(70);
-
-        let lock_by_height = LockTime::from(height);
-        let lock_by_time = LockTime::from(time);
-
-        let seq_height = Sequence::from(lock_by_height);
-        let seq_time = Sequence::from(lock_by_time);
-
-        assert!(lock_by_height.is_implied_by_sequence(seq_height));
-        assert!(!lock_by_height.is_implied_by_sequence(seq_time));
-
-        assert!(lock_by_time.is_implied_by_sequence(seq_time));
-        assert!(!lock_by_time.is_implied_by_sequence(seq_height));
-
-        let disabled_sequence = Sequence::from_consensus(1 << 31);
-        assert!(!lock_by_height.is_implied_by_sequence(disabled_sequence));
-        assert!(!lock_by_time.is_implied_by_sequence(disabled_sequence));
-    }
-
-    #[test]
-    fn incorrect_units_do_not_imply() {
-        let time = NumberOf512Seconds::from_512_second_intervals(70);
-        let height = NumberOfBlocks::from(10);
-
-        let lock_by_time = LockTime::from(time);
-        assert!(!lock_by_time.is_implied_by(LockTime::from(height)));
-    }
-
-    #[test]
-    fn consensus_round_trip() {
-        assert!(LockTime::from_consensus(1 << 31).is_err());
-        assert!(LockTime::from_consensus(1 << 30).is_ok());
-        // Relative locktimes do not care about bits 17 through 21.
-        assert_eq!(LockTime::from_consensus(65536), LockTime::from_consensus(0));
-
-        for val in [0u32, 1, 1000, 65535] {
-            let seq = Sequence::from_consensus(val);
-            let lt = LockTime::from_consensus(val).unwrap();
-            assert_eq!(lt.to_consensus_u32(), val);
-            assert_eq!(lt.to_sequence(), seq);
-            assert_eq!(LockTime::from_sequence(seq).unwrap().to_sequence(), seq);
-
-            let seq = Sequence::from_consensus(val + (1 << 22));
-            let lt = LockTime::from_consensus(val + (1 << 22)).unwrap();
-            assert_eq!(lt.to_consensus_u32(), val + (1 << 22));
-            assert_eq!(lt.to_sequence(), seq);
-            assert_eq!(LockTime::from_sequence(seq).unwrap().to_sequence(), seq);
-        }
-    }
-
-    #[test]
-    fn disabled_locktime_error() {
-        let disabled_sequence = Sequence::from_consensus(1 << 31);
-        let err = LockTime::try_from(disabled_sequence).unwrap_err();
-
-        assert_eq!(err.disabled_locktime_value(), 1 << 31);
-        assert!(!format!("{}", err).is_empty());
-    }
-
-    #[test]
-    fn incompatible_height_error() {
-        let height = NumberOfBlocks::from(10);
-        let time = NumberOf512Seconds::from_512_second_intervals(70);
-        let lock_by_time = LockTime::from(time);
-        let err = lock_by_time.is_satisfied_by_height(height).unwrap_err();
-
-        assert_eq!(err.incompatible(), height);
-        assert_eq!(err.expected(), time);
-        assert!(!format!("{}", err).is_empty());
-    }
-
-    #[test]
-    fn incompatible_time_error() {
-        let height = NumberOfBlocks::from(10);
-        let time = NumberOf512Seconds::from_512_second_intervals(70);
-        let lock_by_height = LockTime::from(height);
-        let err = lock_by_height.is_satisfied_by_time(time).unwrap_err();
-
-        assert_eq!(err.incompatible(), time);
-        assert_eq!(err.expected(), height);
-        assert!(!format!("{}", err).is_empty());
-    }
-
-    #[test]
-    fn test_locktime_chain_state() {
-        fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
-            let mut timestamps = [BlockTime::from_u32(0); 11];
-            for (i, ts) in timestamps.iter_mut().enumerate() {
-                *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
-            }
-            timestamps
-        }
-
-        let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
-        let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
-
-        let chain_height = BlockHeight::from_u32(100);
-        let chain_mtp = BlockMtp::new(timestamps);
-        let utxo_height = BlockHeight::from_u32(80);
-        let utxo_mtp = BlockMtp::new(utxo_timestamps);
-
-        let lock1 = LockTime::Blocks(NumberOfBlocks::from(10));
-        assert!(lock1.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let lock2 = LockTime::Blocks(NumberOfBlocks::from(21));
-        assert!(!lock2.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let lock3 = LockTime::Time(NumberOf512Seconds::from_512_second_intervals(10));
-        assert!(lock3.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let lock4 = LockTime::Time(NumberOf512Seconds::from_512_second_intervals(20000));
-        assert!(!lock4.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        assert!(LockTime::ZERO.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-        assert!(LockTime::from_512_second_intervals(0).is_satisfied_by(
-            chain_height,
-            chain_mtp,
-            utxo_height,
-            utxo_mtp
-        ));
-
-        let lock6 = LockTime::from_seconds_floor(5000).unwrap();
-        assert!(lock6.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let max_height_lock = LockTime::Blocks(NumberOfBlocks::MAX);
-        assert!(!max_height_lock.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let max_time_lock = LockTime::Time(NumberOf512Seconds::MAX);
-        assert!(!max_time_lock.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp));
-
-        let max_chain_height = BlockHeight::from_u32(u32::MAX);
-        let max_chain_mtp = BlockMtp::new(generate_timestamps(u32::MAX, 100));
-        let max_utxo_height = BlockHeight::MAX;
-        let max_utxo_mtp = max_chain_mtp;
-        assert!(!max_height_lock.is_satisfied_by(
-            max_chain_height,
-            max_chain_mtp,
-            max_utxo_height,
-            max_utxo_mtp
-        ));
-        assert!(!max_time_lock.is_satisfied_by(
-            max_chain_height,
-            max_chain_mtp,
-            max_utxo_height,
-            max_utxo_mtp
-        ));
-    }
-}
diff --git a/primitives/src/merkle_tree.rs b/primitives/src/merkle_tree.rs
index e5cc601017..49ac63c8ab 100644
--- a/primitives/src/merkle_tree.rs
+++ b/primitives/src/merkle_tree.rs
@@ -2,18 +2,278 @@
 
 //! Bitcoin Merkle tree functions.
 
-use hashes::sha256d;
+// This module is unusual in that it exists because of a bunch of (krufty) reasons:
+//
+// - We based the name off of the original `bitcoin` module.
+// - We want the API to be the same here as in `bitcoin`.
+// - We define all the other hash types in some module so the merkle tree hash types need a module.
+//
+// C'est la vie.
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
 
-hashes::hash_newtype! {
-    /// A hash of the Merkle tree branch or root for transactions.
-    pub struct TxMerkleNode(sha256d::Hash);
-    /// A hash corresponding to the Merkle tree root for witness data.
-    pub struct WitnessMerkleNode(sha256d::Hash);
+use hashes::{sha256d, HashEngine};
+#[cfg(not(feature = "alloc"))]
+use internals::array_vec::ArrayVec;
+
+#[doc(inline)]
+pub use crate::hash_types::{TxMerkleNode, TxMerkleNodeEncoder, WitnessMerkleNode};
+use crate::hash_types::{Txid, Wtxid};
+use crate::transaction::TxIdentifier;
+
+/// A node in a Merkle tree of transactions or witness data within a block.
+///
+/// This trait is used to compute the transaction Merkle root contained in
+/// a block header. This is a particularly weird algorithm -- it interprets
+/// the list of transactions as a balanced binary tree, duplicating branches
+/// as needed to fill out the tree to a power of two size.
+///
+/// Other Merkle trees in Bitcoin, such as those used in Taproot commitments,
+/// do not use this algorithm and cannot use this trait.
+pub(crate) trait MerkleNode: Copy + PartialEq {
+    /// The hash (TXID or WTXID) of a transaction in the tree.
+    type Leaf: TxIdentifier;
+
+    /// Convert a hash to a leaf node of the tree.
+    fn from_leaf(leaf: Self::Leaf) -> Self;
+    /// Combine two nodes to get a single node. The final node of a tree is called the "root".
+    #[must_use]
+    fn combine(&self, other: &Self) -> Self;
+
+    /// Given an iterator of leaves, compute the Merkle root.
+    ///
+    /// Returns `None` if the iterator was empty, or if the transaction list contains
+    /// consecutive duplicates which would trigger CVE 2012-2459. Blocks with duplicate
+    /// transactions will always be invalid, so there is no harm in us refusing to
+    /// compute their merkle roots.
+    ///
+    /// Also returns `None` if the `alloc` feature is disabled and `iter` has more than
+    /// 32,767 transactions.
+    ///
+    /// Unless you are certain your transaction list is nonempty and has no duplicates,
+    /// you should not unwrap the `Option` returned by this method!
+    fn calculate_root<I: Iterator<Item = Self::Leaf>>(iter: I) -> Option<Self> {
+        {
+            #[cfg(feature = "alloc")]
+            let mut stack = Vec::<(usize, Self)>::with_capacity(32);
+            #[cfg(not(feature = "alloc"))]
+            let mut stack = ArrayVec::<(usize, Self), 15>::new();
+
+            // Start with a standard Merkle tree root computation...
+            for (mut n, leaf) in iter.enumerate() {
+                #[cfg(not(feature = "alloc"))]
+                // This is the only time that the stack actually grows, rather than being combined.
+                if stack.len() == 15 {
+                    return None;
+                }
+                stack.push((0, Self::from_leaf(leaf)));
+
+                while n & 1 == 1 {
+                    let right = stack.pop().unwrap();
+                    let left = stack.pop().unwrap();
+                    if left.1 == right.1 {
+                        // Reject duplicate trees since they are guaranteed-invalid (Bitcoin does
+                        // not allow duplicate transactions in block) but can be used to confuse
+                        // nodes about legitimate blocks. See CVE 2012-2459 and the block comment
+                        // below.
+                        return None;
+                    }
+                    debug_assert_eq!(left.0, right.0);
+                    stack.push((left.0 + 1, left.1.combine(&right.1)));
+                    n >>= 1;
+                }
+            }
+            // ...then, deal with incomplete trees. Bitcoin does a weird thing in
+            // which it doubles-up nodes of the tree to fill out the tree, rather
+            // than treating incomplete branches specially. This makes this tree
+            // construction vulnerable to collisions (see CVE 2012-2459).
+            //
+            // (It is also vulnerable to collisions because it does not distinguish
+            // between internal nodes and transactions, but this collisions of this
+            // form are probably impractical. It is likely that 64-byte transactions
+            // will be forbidden in the future which will close this for good.)
+            //
+            // This is consensus logic so we cannot fix the Merkle tree construction.
+            // Instead we just have to reject the clearly-invalid half of the collision
+            // (see previous comment).
+            while stack.len() > 1 {
+                let mut right = stack.pop().unwrap();
+                let left = stack.pop().unwrap();
+                while right.0 != left.0 {
+                    assert!(right.0 < left.0);
+                    right = (right.0 + 1, right.1.combine(&right.1)); // combine with self
+                }
+                stack.push((left.0 + 1, left.1.combine(&right.1)));
+            }
+
+            stack.pop().map(|(_, h)| h)
+        }
+    }
 }
 
-#[cfg(feature = "hex")]
-hashes::impl_hex_for_newtype!(TxMerkleNode, WitnessMerkleNode);
-#[cfg(not(feature = "hex"))]
-hashes::impl_debug_only_for_newtype!(TxMerkleNode, WitnessMerkleNode);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(TxMerkleNode, WitnessMerkleNode);
+// These two impl blocks are identical. FIXME once we have nailed down
+// our hash traits, it should be possible to put bounds on `MerkleNode`
+// and `MerkleNode::Leaf` which are sufficient to turn both methods into
+// provided methods in the trait definition.
+impl MerkleNode for TxMerkleNode {
+    type Leaf = Txid;
+    fn from_leaf(leaf: Self::Leaf) -> Self { Self::from_byte_array(leaf.to_byte_array()) }
+
+    fn combine(&self, other: &Self) -> Self {
+        let mut encoder = sha256d::Hash::engine();
+        encoder.input(self.as_byte_array());
+        encoder.input(other.as_byte_array());
+        Self::from_byte_array(sha256d::Hash::from_engine(encoder).to_byte_array())
+    }
+}
+impl MerkleNode for WitnessMerkleNode {
+    type Leaf = Wtxid;
+    fn from_leaf(leaf: Self::Leaf) -> Self { Self::from_byte_array(leaf.to_byte_array()) }
+
+    fn combine(&self, other: &Self) -> Self {
+        let mut encoder = sha256d::Hash::engine();
+        encoder.input(self.as_byte_array());
+        encoder.input(other.as_byte_array());
+        Self::from_byte_array(sha256d::Hash::from_engine(encoder).to_byte_array())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::hash_types::*;
+
+    // Helper to make a Txid, TxMerkleNode pair with a single number byte array
+    fn make_leaf_node(byte: u8) -> (Txid, TxMerkleNode) {
+        let leaf = Txid::from_byte_array([byte; 32]);
+        let node = TxMerkleNode::from_leaf(leaf);
+        (leaf, node)
+    }
+
+    #[test]
+    fn tx_merkle_node_single_leaf() {
+        let (leaf, node) = make_leaf_node(1);
+        let root = TxMerkleNode::calculate_root([leaf].into_iter());
+        assert!(root.is_some(), "Root should exist for a single leaf");
+        assert_eq!(root.unwrap(), node, "Root should equal the leaf node");
+    }
+
+    #[test]
+    fn tx_merkle_node_two_leaves() {
+        let (leaf1, node1) = make_leaf_node(1);
+        let (leaf2, node2) = make_leaf_node(2);
+        let combined = node1.combine(&node2);
+
+        let root = TxMerkleNode::calculate_root([leaf1, leaf2].into_iter());
+        assert_eq!(
+            root.unwrap(),
+            combined,
+            "Root of two leaves should equal combine of the two leaf nodes"
+        );
+    }
+
+    #[test]
+    fn tx_merkle_node_duplicate_leaves() {
+        let leaf = Txid::from_byte_array([3; 32]);
+        // Duplicate transaction list should be rejected (CVE 2012‑2459).
+        let root = TxMerkleNode::calculate_root([leaf, leaf].into_iter());
+        assert!(root.is_none(), "Duplicate leaves should return None");
+    }
+
+    #[test]
+    fn tx_merkle_node_empty() {
+        assert!(
+            TxMerkleNode::calculate_root([].into_iter()).is_none(),
+            "Empty iterator should return None"
+        );
+    }
+
+    #[test]
+    fn tx_merkle_node_2n_minus_1_unbalanced_tree() {
+        // Test a tree with 2^n - 1 unique nodes and at least 3 layers deep.
+        let (leaf1, node1) = make_leaf_node(1);
+        let (leaf2, node2) = make_leaf_node(2);
+        let (leaf3, node3) = make_leaf_node(3);
+        let (leaf4, node4) = make_leaf_node(4);
+        let (leaf5, node5) = make_leaf_node(5);
+        let (leaf6, node6) = make_leaf_node(6);
+        let (leaf7, node7) = make_leaf_node(7);
+
+        // Combine leaf nodes
+        let subtree_a = node1.combine(&node2);
+        let subtree_b = node3.combine(&node4);
+        let subtree_c = node5.combine(&node6);
+        let subtree_d = node7.combine(&node7); // doubled
+
+        // Combine the subtrees
+        let subtree_ab = subtree_a.combine(&subtree_b);
+        let subtree_cd = subtree_c.combine(&subtree_d);
+        let expected = subtree_ab.combine(&subtree_cd);
+
+        let root = TxMerkleNode::calculate_root(
+            [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7].into_iter(),
+        );
+        assert_eq!(root, Some(expected));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn tx_merkle_node_balanced_multi_level_tree() {
+        use alloc::vec::Vec;
+
+        let leaves: Vec<_> = (0..16).map(|i| Txid::from_byte_array([i; 32])).collect();
+
+        // Create nodes for the txids.
+        let mut level = leaves.iter().map(|l| TxMerkleNode::from_leaf(*l)).collect::<Vec<_>>();
+
+        // Combine the leaves into a tree, ordered from left-to-right in the initial vector.
+        while level.len() > 1 {
+            level = level.chunks(2).map(|chunk| chunk[0].combine(&chunk[1])).collect();
+        }
+
+        // Take the final node, which should be the root of the full tree.
+        let expected = level.pop().unwrap();
+
+        let root = TxMerkleNode::calculate_root(leaves.into_iter());
+        assert_eq!(root, Some(expected));
+    }
+
+    #[test]
+    fn tx_merkle_node_oversize_tree() {
+        // Confirm that with no-alloc, we return None for iter length >= 32768
+        let root = TxMerkleNode::calculate_root((0..32768u32).map(|i| {
+            let mut buf = [0u8; 32];
+            buf[..4].copy_from_slice(&i.to_le_bytes());
+            Txid::from_byte_array(buf)
+        }));
+
+        // We just want to confirm that we return None at the 32768 element boundary.
+        #[cfg(feature = "alloc")]
+        assert_ne!(root, None);
+        #[cfg(not(feature = "alloc"))]
+        assert_eq!(root, None);
+
+        // Check just under the boundary
+        let root = TxMerkleNode::calculate_root((0..32767u32).map(|i| {
+            let mut buf = [0u8; 32];
+            buf[..4].copy_from_slice(&i.to_le_bytes());
+            Txid::from_byte_array(buf)
+        }));
+        assert_ne!(root, None);
+    }
+
+    #[test]
+    fn witness_merkle_node_single_leaf() {
+        let leaf = Wtxid::from_byte_array([1; 32]);
+        let root = WitnessMerkleNode::calculate_root([leaf].into_iter());
+        assert!(root.is_some(), "Root should exist for a single witness leaf");
+        let node = WitnessMerkleNode::from_leaf(leaf);
+        assert_eq!(root.unwrap(), node, "Root should equal the leaf node");
+    }
+
+    #[test]
+    fn witness_merkle_node_duplicate_leaves() {
+        let leaf = Wtxid::from_byte_array([2; 32]);
+        let root = WitnessMerkleNode::calculate_root([leaf, leaf].into_iter());
+        assert!(root.is_none(), "Duplicate witness leaves should return None");
+    }
+}
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 8438445569..4d39abf063 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -6,900 +6,116 @@
 //! all of the opcodes for that language.
 
 #![allow(non_camel_case_types)]
-#![allow(dead_code)] // This module is private and is duplicated in `bitcoin`.
 
 use core::fmt;
 
-#[cfg(feature = "serde")]
-use crate::prelude::ToString;
-
-/// A script Opcode.
-///
-/// We do not implement Ord on this type because there is no natural ordering on opcodes, but there
-/// may appear to be one (e.g. because all the push opcodes appear in a consecutive block) and we
-/// don't want to encourage subtly buggy code. Please use [`Opcode::classify`] to distinguish different
-/// types of opcodes.
-///
-/// <details>
-///   <summary>Example of Core bug caused by assuming ordering</summary>
-///
-///   Bitcoin Core's `IsPushOnly` considers `OP_RESERVED` to be a "push code", allowing this opcode
-///   in contexts where only pushes are supposed to be allowed.
-/// </details>
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct Opcode {
-    code: u8,
-}
-
-#[allow(clippy::wildcard_imports)]
-use self::all::*;
-
-macro_rules! all_opcodes {
-    ($($op:ident => $val:expr, $doc:expr);*) => {
-        /// Enables wildcard imports to bring into scope all opcodes and nothing else.
-        ///
-        /// The `all` module is provided so one can use a wildcard import `use bitcoin::opcodes::all::*` to
-        /// get all the `OP_FOO` opcodes without getting other types defined in `opcodes` (e.g. `Opcode`, `Class`).
-        ///
-        /// This module is guaranteed to never contain anything except opcode constants and all opcode
-        /// constants are guaranteed to begin with `OP_`.
-        pub mod all {
-            use super::Opcode;
-            $(
-                #[doc = $doc]
-                pub const $op: Opcode = Opcode { code: $val};
-            )*
-        }
-
-        /// Push an empty array onto the stack.
-        pub static OP_0: Opcode = OP_PUSHBYTES_0;
-        /// Empty stack is also `FALSE`.
-        pub static OP_FALSE: Opcode = OP_PUSHBYTES_0;
-        /// Number 1 is also TRUE.
-        pub static OP_TRUE: Opcode = OP_PUSHNUM_1;
-        /// Previously called `OP_NOP2`.
-        pub static OP_NOP2: Opcode = OP_CLTV;
-        /// Previously called `OP_NOP3`.
-        pub static OP_NOP3: Opcode = OP_CSV;
-
-        impl fmt::Display for Opcode {
-            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                 match *self {
-                   $(
-                        $op => core::fmt::Display::fmt(stringify!($op), f),
-                    )+
-                }
-            }
-        }
-    }
-}
-
-all_opcodes! {
-    OP_PUSHBYTES_0 => 0x00, "Push an empty array onto the stack.";
-    OP_PUSHBYTES_1 => 0x01, "Push the next byte as an array onto the stack.";
-    OP_PUSHBYTES_2 => 0x02, "Push the next 2 bytes as an array onto the stack.";
-    OP_PUSHBYTES_3 => 0x03, "Push the next 3 bytes as an array onto the stack.";
-    OP_PUSHBYTES_4 => 0x04, "Push the next 4 bytes as an array onto the stack.";
-    OP_PUSHBYTES_5 => 0x05, "Push the next 5 bytes as an array onto the stack.";
-    OP_PUSHBYTES_6 => 0x06, "Push the next 6 bytes as an array onto the stack.";
-    OP_PUSHBYTES_7 => 0x07, "Push the next 7 bytes as an array onto the stack.";
-    OP_PUSHBYTES_8 => 0x08, "Push the next 8 bytes as an array onto the stack.";
-    OP_PUSHBYTES_9 => 0x09, "Push the next 9 bytes as an array onto the stack.";
-    OP_PUSHBYTES_10 => 0x0a, "Push the next 10 bytes as an array onto the stack.";
-    OP_PUSHBYTES_11 => 0x0b, "Push the next 11 bytes as an array onto the stack.";
-    OP_PUSHBYTES_12 => 0x0c, "Push the next 12 bytes as an array onto the stack.";
-    OP_PUSHBYTES_13 => 0x0d, "Push the next 13 bytes as an array onto the stack.";
-    OP_PUSHBYTES_14 => 0x0e, "Push the next 14 bytes as an array onto the stack.";
-    OP_PUSHBYTES_15 => 0x0f, "Push the next 15 bytes as an array onto the stack.";
-    OP_PUSHBYTES_16 => 0x10, "Push the next 16 bytes as an array onto the stack.";
-    OP_PUSHBYTES_17 => 0x11, "Push the next 17 bytes as an array onto the stack.";
-    OP_PUSHBYTES_18 => 0x12, "Push the next 18 bytes as an array onto the stack.";
-    OP_PUSHBYTES_19 => 0x13, "Push the next 19 bytes as an array onto the stack.";
-    OP_PUSHBYTES_20 => 0x14, "Push the next 20 bytes as an array onto the stack.";
-    OP_PUSHBYTES_21 => 0x15, "Push the next 21 bytes as an array onto the stack.";
-    OP_PUSHBYTES_22 => 0x16, "Push the next 22 bytes as an array onto the stack.";
-    OP_PUSHBYTES_23 => 0x17, "Push the next 23 bytes as an array onto the stack.";
-    OP_PUSHBYTES_24 => 0x18, "Push the next 24 bytes as an array onto the stack.";
-    OP_PUSHBYTES_25 => 0x19, "Push the next 25 bytes as an array onto the stack.";
-    OP_PUSHBYTES_26 => 0x1a, "Push the next 26 bytes as an array onto the stack.";
-    OP_PUSHBYTES_27 => 0x1b, "Push the next 27 bytes as an array onto the stack.";
-    OP_PUSHBYTES_28 => 0x1c, "Push the next 28 bytes as an array onto the stack.";
-    OP_PUSHBYTES_29 => 0x1d, "Push the next 29 bytes as an array onto the stack.";
-    OP_PUSHBYTES_30 => 0x1e, "Push the next 30 bytes as an array onto the stack.";
-    OP_PUSHBYTES_31 => 0x1f, "Push the next 31 bytes as an array onto the stack.";
-    OP_PUSHBYTES_32 => 0x20, "Push the next 32 bytes as an array onto the stack.";
-    OP_PUSHBYTES_33 => 0x21, "Push the next 33 bytes as an array onto the stack.";
-    OP_PUSHBYTES_34 => 0x22, "Push the next 34 bytes as an array onto the stack.";
-    OP_PUSHBYTES_35 => 0x23, "Push the next 35 bytes as an array onto the stack.";
-    OP_PUSHBYTES_36 => 0x24, "Push the next 36 bytes as an array onto the stack.";
-    OP_PUSHBYTES_37 => 0x25, "Push the next 37 bytes as an array onto the stack.";
-    OP_PUSHBYTES_38 => 0x26, "Push the next 38 bytes as an array onto the stack.";
-    OP_PUSHBYTES_39 => 0x27, "Push the next 39 bytes as an array onto the stack.";
-    OP_PUSHBYTES_40 => 0x28, "Push the next 40 bytes as an array onto the stack.";
-    OP_PUSHBYTES_41 => 0x29, "Push the next 41 bytes as an array onto the stack.";
-    OP_PUSHBYTES_42 => 0x2a, "Push the next 42 bytes as an array onto the stack.";
-    OP_PUSHBYTES_43 => 0x2b, "Push the next 43 bytes as an array onto the stack.";
-    OP_PUSHBYTES_44 => 0x2c, "Push the next 44 bytes as an array onto the stack.";
-    OP_PUSHBYTES_45 => 0x2d, "Push the next 45 bytes as an array onto the stack.";
-    OP_PUSHBYTES_46 => 0x2e, "Push the next 46 bytes as an array onto the stack.";
-    OP_PUSHBYTES_47 => 0x2f, "Push the next 47 bytes as an array onto the stack.";
-    OP_PUSHBYTES_48 => 0x30, "Push the next 48 bytes as an array onto the stack.";
-    OP_PUSHBYTES_49 => 0x31, "Push the next 49 bytes as an array onto the stack.";
-    OP_PUSHBYTES_50 => 0x32, "Push the next 50 bytes as an array onto the stack.";
-    OP_PUSHBYTES_51 => 0x33, "Push the next 51 bytes as an array onto the stack.";
-    OP_PUSHBYTES_52 => 0x34, "Push the next 52 bytes as an array onto the stack.";
-    OP_PUSHBYTES_53 => 0x35, "Push the next 53 bytes as an array onto the stack.";
-    OP_PUSHBYTES_54 => 0x36, "Push the next 54 bytes as an array onto the stack.";
-    OP_PUSHBYTES_55 => 0x37, "Push the next 55 bytes as an array onto the stack.";
-    OP_PUSHBYTES_56 => 0x38, "Push the next 56 bytes as an array onto the stack.";
-    OP_PUSHBYTES_57 => 0x39, "Push the next 57 bytes as an array onto the stack.";
-    OP_PUSHBYTES_58 => 0x3a, "Push the next 58 bytes as an array onto the stack.";
-    OP_PUSHBYTES_59 => 0x3b, "Push the next 59 bytes as an array onto the stack.";
-    OP_PUSHBYTES_60 => 0x3c, "Push the next 60 bytes as an array onto the stack.";
-    OP_PUSHBYTES_61 => 0x3d, "Push the next 61 bytes as an array onto the stack.";
-    OP_PUSHBYTES_62 => 0x3e, "Push the next 62 bytes as an array onto the stack.";
-    OP_PUSHBYTES_63 => 0x3f, "Push the next 63 bytes as an array onto the stack.";
-    OP_PUSHBYTES_64 => 0x40, "Push the next 64 bytes as an array onto the stack.";
-    OP_PUSHBYTES_65 => 0x41, "Push the next 65 bytes as an array onto the stack.";
-    OP_PUSHBYTES_66 => 0x42, "Push the next 66 bytes as an array onto the stack.";
-    OP_PUSHBYTES_67 => 0x43, "Push the next 67 bytes as an array onto the stack.";
-    OP_PUSHBYTES_68 => 0x44, "Push the next 68 bytes as an array onto the stack.";
-    OP_PUSHBYTES_69 => 0x45, "Push the next 69 bytes as an array onto the stack.";
-    OP_PUSHBYTES_70 => 0x46, "Push the next 70 bytes as an array onto the stack.";
-    OP_PUSHBYTES_71 => 0x47, "Push the next 71 bytes as an array onto the stack.";
-    OP_PUSHBYTES_72 => 0x48, "Push the next 72 bytes as an array onto the stack.";
-    OP_PUSHBYTES_73 => 0x49, "Push the next 73 bytes as an array onto the stack.";
-    OP_PUSHBYTES_74 => 0x4a, "Push the next 74 bytes as an array onto the stack.";
-    OP_PUSHBYTES_75 => 0x4b, "Push the next 75 bytes as an array onto the stack.";
-    OP_PUSHDATA1 => 0x4c, "Read the next byte as N; push the next N bytes as an array onto the stack.";
-    OP_PUSHDATA2 => 0x4d, "Read the next 2 bytes as N; push the next N bytes as an array onto the stack.";
-    OP_PUSHDATA4 => 0x4e, "Read the next 4 bytes as N; push the next N bytes as an array onto the stack.";
-    OP_PUSHNUM_NEG1 => 0x4f, "Push the array `0x81` onto the stack.";
-    OP_RESERVED => 0x50, "Synonym for OP_RETURN.";
-    OP_PUSHNUM_1 => 0x51, "Push the array `0x01` onto the stack.";
-    OP_PUSHNUM_2 => 0x52, "Push the array `0x02` onto the stack.";
-    OP_PUSHNUM_3 => 0x53, "Push the array `0x03` onto the stack.";
-    OP_PUSHNUM_4 => 0x54, "Push the array `0x04` onto the stack.";
-    OP_PUSHNUM_5 => 0x55, "Push the array `0x05` onto the stack.";
-    OP_PUSHNUM_6 => 0x56, "Push the array `0x06` onto the stack.";
-    OP_PUSHNUM_7 => 0x57, "Push the array `0x07` onto the stack.";
-    OP_PUSHNUM_8 => 0x58, "Push the array `0x08` onto the stack.";
-    OP_PUSHNUM_9 => 0x59, "Push the array `0x09` onto the stack.";
-    OP_PUSHNUM_10 => 0x5a, "Push the array `0x0a` onto the stack.";
-    OP_PUSHNUM_11 => 0x5b, "Push the array `0x0b` onto the stack.";
-    OP_PUSHNUM_12 => 0x5c, "Push the array `0x0c` onto the stack.";
-    OP_PUSHNUM_13 => 0x5d, "Push the array `0x0d` onto the stack.";
-    OP_PUSHNUM_14 => 0x5e, "Push the array `0x0e` onto the stack.";
-    OP_PUSHNUM_15 => 0x5f, "Push the array `0x0f` onto the stack.";
-    OP_PUSHNUM_16 => 0x60, "Push the array `0x10` onto the stack.";
-    OP_NOP => 0x61, "Does nothing.";
-    OP_VER => 0x62, "Synonym for OP_RETURN.";
-    OP_IF => 0x63, "Pop and execute the next statements if a nonzero element was popped.";
-    OP_NOTIF => 0x64, "Pop and execute the next statements if a zero element was popped.";
-    OP_VERIF => 0x65, "Fail the script unconditionally, does not even need to be executed.";
-    OP_VERNOTIF => 0x66, "Fail the script unconditionally, does not even need to be executed.";
-    OP_ELSE => 0x67, "Execute statements if those after the previous OP_IF were not, and vice-versa. \
-             If there is no previous OP_IF, this acts as a RETURN.";
-    OP_ENDIF => 0x68, "Pop and execute the next statements if a zero element was popped.";
-    OP_VERIFY => 0x69, "If the top value is zero or the stack is empty, fail; otherwise, pop the stack.";
-    OP_RETURN => 0x6a, "Fail the script immediately. (Must be executed.).";
-    OP_TOALTSTACK => 0x6b, "Pop one element from the main stack onto the alt stack.";
-    OP_FROMALTSTACK => 0x6c, "Pop one element from the alt stack onto the main stack.";
-    OP_2DROP => 0x6d, "Drops the top two stack items.";
-    OP_2DUP => 0x6e, "Duplicates the top two stack items as AB -> ABAB.";
-    OP_3DUP => 0x6f, "Duplicates the two three stack items as ABC -> ABCABC.";
-    OP_2OVER => 0x70, "Copies the two stack items of items two spaces back to the front, as xxAB -> ABxxAB.";
-    OP_2ROT => 0x71, "Moves the two stack items four spaces back to the front, as xxxxAB -> ABxxxx.";
-    OP_2SWAP => 0x72, "Swaps the top two pairs, as ABCD -> CDAB.";
-    OP_IFDUP => 0x73, "Duplicate the top stack element unless it is zero.";
-    OP_DEPTH => 0x74, "Push the current number of stack items onto the stack.";
-    OP_DROP => 0x75, "Drops the top stack item.";
-    OP_DUP => 0x76, "Duplicates the top stack item.";
-    OP_NIP => 0x77, "Drops the second-to-top stack item.";
-    OP_OVER => 0x78, "Copies the second-to-top stack item, as xA -> AxA.";
-    OP_PICK => 0x79, "Pop the top stack element as N. Copy the Nth stack element to the top.";
-    OP_ROLL => 0x7a, "Pop the top stack element as N. Move the Nth stack element to the top.";
-    OP_ROT => 0x7b, "Rotate the top three stack items, as [top next1 next2] -> [next2 top next1].";
-    OP_SWAP => 0x7c, "Swap the top two stack items.";
-    OP_TUCK => 0x7d, "Copy the top stack item to before the second item, as [top next] -> [top next top].";
-    OP_CAT => 0x7e, "Fail the script unconditionally, does not even need to be executed.";
-    OP_SUBSTR => 0x7f, "Fail the script unconditionally, does not even need to be executed.";
-    OP_LEFT => 0x80, "Fail the script unconditionally, does not even need to be executed.";
-    OP_RIGHT => 0x81, "Fail the script unconditionally, does not even need to be executed.";
-    OP_SIZE => 0x82, "Pushes the length of the top stack item onto the stack.";
-    OP_INVERT => 0x83, "Fail the script unconditionally, does not even need to be executed.";
-    OP_AND => 0x84, "Fail the script unconditionally, does not even need to be executed.";
-    OP_OR => 0x85, "Fail the script unconditionally, does not even need to be executed.";
-    OP_XOR => 0x86, "Fail the script unconditionally, does not even need to be executed.";
-    OP_EQUAL => 0x87, "Pushes 1 if the inputs are exactly equal, 0 otherwise.";
-    OP_EQUALVERIFY => 0x88, "Returns success if the inputs are exactly equal, failure otherwise.";
-    OP_RESERVED1 => 0x89, "Synonym for OP_RETURN.";
-    OP_RESERVED2 => 0x8a, "Synonym for OP_RETURN.";
-    OP_1ADD => 0x8b, "Increment the top stack element in place.";
-    OP_1SUB => 0x8c, "Decrement the top stack element in place.";
-    OP_2MUL => 0x8d, "Fail the script unconditionally, does not even need to be executed.";
-    OP_2DIV => 0x8e, "Fail the script unconditionally, does not even need to be executed.";
-    OP_NEGATE => 0x8f, "Multiply the top stack item by -1 in place.";
-    OP_ABS => 0x90, "Absolute value the top stack item in place.";
-    OP_NOT => 0x91, "Map 0 to 1 and everything else to 0, in place.";
-    OP_0NOTEQUAL => 0x92, "Map 0 to 0 and everything else to 1, in place.";
-    OP_ADD => 0x93, "Pop two stack items and push their sum.";
-    OP_SUB => 0x94, "Pop two stack items and push the second minus the top.";
-    OP_MUL => 0x95, "Fail the script unconditionally, does not even need to be executed.";
-    OP_DIV => 0x96, "Fail the script unconditionally, does not even need to be executed.";
-    OP_MOD => 0x97, "Fail the script unconditionally, does not even need to be executed.";
-    OP_LSHIFT => 0x98, "Fail the script unconditionally, does not even need to be executed.";
-    OP_RSHIFT => 0x99, "Fail the script unconditionally, does not even need to be executed.";
-    OP_BOOLAND => 0x9a, "Pop the top two stack items and push 1 if both are nonzero, else push 0.";
-    OP_BOOLOR => 0x9b, "Pop the top two stack items and push 1 if either is nonzero, else push 0.";
-    OP_NUMEQUAL => 0x9c, "Pop the top two stack items and push 1 if both are numerically equal, else push 0.";
-    OP_NUMEQUALVERIFY => 0x9d, "Pop the top two stack items and return success if both are numerically equal, else return failure.";
-    OP_NUMNOTEQUAL => 0x9e, "Pop the top two stack items and push 0 if both are numerically equal, else push 1.";
-    OP_LESSTHAN  => 0x9f, "Pop the top two items; push 1 if the second is less than the top, 0 otherwise.";
-    OP_GREATERTHAN  => 0xa0, "Pop the top two items; push 1 if the second is greater than the top, 0 otherwise.";
-    OP_LESSTHANOREQUAL  => 0xa1, "Pop the top two items; push 1 if the second is <= the top, 0 otherwise.";
-    OP_GREATERTHANOREQUAL  => 0xa2, "Pop the top two items; push 1 if the second is >= the top, 0 otherwise.";
-    OP_MIN => 0xa3, "Pop the top two items; push the smaller.";
-    OP_MAX => 0xa4, "Pop the top two items; push the larger.";
-    OP_WITHIN => 0xa5, "Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0.";
-    OP_RIPEMD160 => 0xa6, "Pop the top stack item and push its RIPEMD160 hash.";
-    OP_SHA1 => 0xa7, "Pop the top stack item and push its SHA1 hash.";
-    OP_SHA256 => 0xa8, "Pop the top stack item and push its SHA256 hash.";
-    OP_HASH160 => 0xa9, "Pop the top stack item and push its RIPEMD(SHA256) hash.";
-    OP_HASH256 => 0xaa, "Pop the top stack item and push its SHA256(SHA256) hash.";
-    OP_CODESEPARATOR => 0xab, "Ignore this and everything preceding when deciding what to sign when signature-checking.";
-    OP_CHECKSIG => 0xac, "<https://en.bitcoin.it/wiki/OP_CHECKSIG> pushing 1/0 for success/failure.";
-    OP_CHECKSIGVERIFY => 0xad, "<https://en.bitcoin.it/wiki/OP_CHECKSIG> returning success/failure.";
-    OP_CHECKMULTISIG => 0xae, "Pop N, N pubkeys, M, M signatures, a dummy (due to bug in reference code), \
-                      and verify that all M signatures are valid. Push 1 for 'all valid', 0 otherwise.";
-    OP_CHECKMULTISIGVERIFY => 0xaf, "Like the above but return success/failure.";
-    OP_NOP1 => 0xb0, "Does nothing.";
-    OP_CLTV => 0xb1, "<https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>";
-    OP_CSV => 0xb2, "<https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki>";
-    OP_NOP4 => 0xb3, "Does nothing.";
-    OP_NOP5 => 0xb4, "Does nothing.";
-    OP_NOP6 => 0xb5, "Does nothing.";
-    OP_NOP7 => 0xb6, "Does nothing.";
-    OP_NOP8 => 0xb7, "Does nothing.";
-    OP_NOP9 => 0xb8, "Does nothing.";
-    OP_NOP10 => 0xb9, "Does nothing.";
-    // Every other opcode acts as OP_RETURN
-    OP_CHECKSIGADD => 0xba, "OP_CHECKSIGADD post tapscript.";
-    OP_RETURN_187 => 0xbb, "Synonym for OP_RETURN.";
-    OP_RETURN_188 => 0xbc, "Synonym for OP_RETURN.";
-    OP_RETURN_189 => 0xbd, "Synonym for OP_RETURN.";
-    OP_RETURN_190 => 0xbe, "Synonym for OP_RETURN.";
-    OP_RETURN_191 => 0xbf, "Synonym for OP_RETURN.";
-    OP_RETURN_192 => 0xc0, "Synonym for OP_RETURN.";
-    OP_RETURN_193 => 0xc1, "Synonym for OP_RETURN.";
-    OP_RETURN_194 => 0xc2, "Synonym for OP_RETURN.";
-    OP_RETURN_195 => 0xc3, "Synonym for OP_RETURN.";
-    OP_RETURN_196 => 0xc4, "Synonym for OP_RETURN.";
-    OP_RETURN_197 => 0xc5, "Synonym for OP_RETURN.";
-    OP_RETURN_198 => 0xc6, "Synonym for OP_RETURN.";
-    OP_RETURN_199 => 0xc7, "Synonym for OP_RETURN.";
-    OP_RETURN_200 => 0xc8, "Synonym for OP_RETURN.";
-    OP_RETURN_201 => 0xc9, "Synonym for OP_RETURN.";
-    OP_RETURN_202 => 0xca, "Synonym for OP_RETURN.";
-    OP_RETURN_203 => 0xcb, "Synonym for OP_RETURN.";
-    OP_RETURN_204 => 0xcc, "Synonym for OP_RETURN.";
-    OP_RETURN_205 => 0xcd, "Synonym for OP_RETURN.";
-    OP_RETURN_206 => 0xce, "Synonym for OP_RETURN.";
-    OP_RETURN_207 => 0xcf, "Synonym for OP_RETURN.";
-    OP_RETURN_208 => 0xd0, "Synonym for OP_RETURN.";
-    OP_RETURN_209 => 0xd1, "Synonym for OP_RETURN.";
-    OP_RETURN_210 => 0xd2, "Synonym for OP_RETURN.";
-    OP_RETURN_211 => 0xd3, "Synonym for OP_RETURN.";
-    OP_RETURN_212 => 0xd4, "Synonym for OP_RETURN.";
-    OP_RETURN_213 => 0xd5, "Synonym for OP_RETURN.";
-    OP_RETURN_214 => 0xd6, "Synonym for OP_RETURN.";
-    OP_RETURN_215 => 0xd7, "Synonym for OP_RETURN.";
-    OP_RETURN_216 => 0xd8, "Synonym for OP_RETURN.";
-    OP_RETURN_217 => 0xd9, "Synonym for OP_RETURN.";
-    OP_RETURN_218 => 0xda, "Synonym for OP_RETURN.";
-    OP_RETURN_219 => 0xdb, "Synonym for OP_RETURN.";
-    OP_RETURN_220 => 0xdc, "Synonym for OP_RETURN.";
-    OP_RETURN_221 => 0xdd, "Synonym for OP_RETURN.";
-    OP_RETURN_222 => 0xde, "Synonym for OP_RETURN.";
-    OP_RETURN_223 => 0xdf, "Synonym for OP_RETURN.";
-    OP_RETURN_224 => 0xe0, "Synonym for OP_RETURN.";
-    OP_RETURN_225 => 0xe1, "Synonym for OP_RETURN.";
-    OP_RETURN_226 => 0xe2, "Synonym for OP_RETURN.";
-    OP_RETURN_227 => 0xe3, "Synonym for OP_RETURN.";
-    OP_RETURN_228 => 0xe4, "Synonym for OP_RETURN.";
-    OP_RETURN_229 => 0xe5, "Synonym for OP_RETURN.";
-    OP_RETURN_230 => 0xe6, "Synonym for OP_RETURN.";
-    OP_RETURN_231 => 0xe7, "Synonym for OP_RETURN.";
-    OP_RETURN_232 => 0xe8, "Synonym for OP_RETURN.";
-    OP_RETURN_233 => 0xe9, "Synonym for OP_RETURN.";
-    OP_RETURN_234 => 0xea, "Synonym for OP_RETURN.";
-    OP_RETURN_235 => 0xeb, "Synonym for OP_RETURN.";
-    OP_RETURN_236 => 0xec, "Synonym for OP_RETURN.";
-    OP_RETURN_237 => 0xed, "Synonym for OP_RETURN.";
-    OP_RETURN_238 => 0xee, "Synonym for OP_RETURN.";
-    OP_RETURN_239 => 0xef, "Synonym for OP_RETURN.";
-    OP_RETURN_240 => 0xf0, "Synonym for OP_RETURN.";
-    OP_RETURN_241 => 0xf1, "Synonym for OP_RETURN.";
-    OP_RETURN_242 => 0xf2, "Synonym for OP_RETURN.";
-    OP_RETURN_243 => 0xf3, "Synonym for OP_RETURN.";
-    OP_RETURN_244 => 0xf4, "Synonym for OP_RETURN.";
-    OP_RETURN_245 => 0xf5, "Synonym for OP_RETURN.";
-    OP_RETURN_246 => 0xf6, "Synonym for OP_RETURN.";
-    OP_RETURN_247 => 0xf7, "Synonym for OP_RETURN.";
-    OP_RETURN_248 => 0xf8, "Synonym for OP_RETURN.";
-    OP_RETURN_249 => 0xf9, "Synonym for OP_RETURN.";
-    OP_RETURN_250 => 0xfa, "Synonym for OP_RETURN.";
-    OP_RETURN_251 => 0xfb, "Synonym for OP_RETURN.";
-    OP_RETURN_252 => 0xfc, "Synonym for OP_RETURN.";
-    OP_RETURN_253 => 0xfd, "Synonym for OP_RETURN.";
-    OP_RETURN_254 => 0xfe, "Synonym for OP_RETURN.";
-    OP_INVALIDOPCODE => 0xff, "Synonym for OP_RETURN."
-}
-
-/// Classification context for the opcode.
-///
-/// Some opcodes like [`OP_RESERVED`] abort the script in `ClassifyContext::Legacy` context,
-/// but will act as `OP_SUCCESSx` in `ClassifyContext::TapScript` (see BIP342 for full list).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum ClassifyContext {
-    /// Opcode used in tapscript context.
-    TapScript,
-    /// Opcode used in legacy context.
-    Legacy,
-}
-
-impl Opcode {
-    /// Classifies an Opcode into a broad class.
-    #[inline]
-    #[must_use]
-    pub fn classify(self, ctx: ClassifyContext) -> Class {
-        match (self, ctx) {
-            // 3 opcodes illegal in all contexts
-            (OP_VERIF, _) | (OP_VERNOTIF, _) | (OP_INVALIDOPCODE, _) => Class::IllegalOp,
-
-            // 15 opcodes illegal in Legacy context
-            #[rustfmt::skip]
-            (OP_CAT, ctx) | (OP_SUBSTR, ctx)
-            | (OP_LEFT, ctx) | (OP_RIGHT, ctx)
-            | (OP_INVERT, ctx)
-            | (OP_AND, ctx) | (OP_OR, ctx) | (OP_XOR, ctx)
-            | (OP_2MUL, ctx) | (OP_2DIV, ctx)
-            | (OP_MUL, ctx) | (OP_DIV, ctx) | (OP_MOD, ctx)
-            | (OP_LSHIFT, ctx) | (OP_RSHIFT, ctx) if ctx == ClassifyContext::Legacy => Class::IllegalOp,
-
-            // 87 opcodes of SuccessOp class only in TapScript context
-            (op, ClassifyContext::TapScript)
-                if op.code == 80
-                    || op.code == 98
-                    || (op.code >= 126 && op.code <= 129)
-                    || (op.code >= 131 && op.code <= 134)
-                    || (op.code >= 137 && op.code <= 138)
-                    || (op.code >= 141 && op.code <= 142)
-                    || (op.code >= 149 && op.code <= 153)
-                    || (op.code >= 187 && op.code <= 254) =>
-                Class::SuccessOp,
-
-            // 11 opcodes of NoOp class
-            (OP_NOP, _) => Class::NoOp,
-            (op, _) if op.code >= OP_NOP1.code && op.code <= OP_NOP10.code => Class::NoOp,
-
-            // 1 opcode for `OP_RETURN`
-            (OP_RETURN, _) => Class::ReturnOp,
-
-            // 4 opcodes operating equally to `OP_RETURN` only in Legacy context
-            (OP_RESERVED, ctx) | (OP_RESERVED1, ctx) | (OP_RESERVED2, ctx) | (OP_VER, ctx)
-                if ctx == ClassifyContext::Legacy =>
-                Class::ReturnOp,
-
-            // 71 opcodes operating equally to `OP_RETURN` only in Legacy context
-            (op, ClassifyContext::Legacy) if op.code >= OP_CHECKSIGADD.code => Class::ReturnOp,
-
-            // 2 opcodes operating equally to `OP_RETURN` only in TapScript context
-            (OP_CHECKMULTISIG, ClassifyContext::TapScript)
-            | (OP_CHECKMULTISIGVERIFY, ClassifyContext::TapScript) => Class::ReturnOp,
-
-            // 1 opcode of PushNum class
-            (OP_PUSHNUM_NEG1, _) => Class::PushNum(-1),
-
-            // 16 opcodes of PushNum class
-            (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
-                Class::PushNum(1 + i32::from(self.code) - i32::from(OP_PUSHNUM_1.code)),
-
-            // 76 opcodes of PushBytes class
-            (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(u32::from(self.code)),
-
-            // opcodes of Ordinary class: 61 for Legacy and 60 for TapScript context
-            (_, _) => Class::Ordinary(Ordinary::with(self)),
-        }
-    }
-
-    /// Encodes [`Opcode`] as a byte.
-    #[inline]
-    pub const fn to_u8(self) -> u8 { self.code }
-
-    /// Encodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
-    ///
-    /// Does not convert `OP_FALSE` to 0. Only `1` to `OP_PUSHNUM_16` are covered.
-    ///
-    /// # Returns
-    ///
-    /// Returns `None` if `self` is not a PUSHNUM.
-    #[inline]
-    #[must_use]
-    pub const fn decode_pushnum(self) -> Option<u8> {
-        const START: u8 = OP_PUSHNUM_1.code;
-        const END: u8 = OP_PUSHNUM_16.code;
-        match self.code {
-            START..=END => Some(self.code - START + 1),
-            _ => None,
-        }
-    }
-}
-
-impl From<u8> for Opcode {
-    #[inline]
-    fn from(b: u8) -> Opcode { Opcode { code: b } }
-}
-
-impl fmt::Debug for Opcode {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Opcode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-/// Broad categories of opcodes with similar behavior.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Class {
-    /// Pushes the given number onto the stack.
-    PushNum(i32),
-    /// Pushes the given number of bytes onto the stack.
-    PushBytes(u32),
-    /// Fails the script if executed.
-    ReturnOp,
-    /// Succeeds the script even if not executed.
-    SuccessOp,
-    /// Fails the script even if not executed.
-    IllegalOp,
-    /// Does nothing.
-    NoOp,
-    /// Any opcode not covered above.
-    Ordinary(Ordinary),
-}
-
-macro_rules! ordinary_opcode {
-    ($($op:ident),*) => (
-        #[repr(u8)]
-        #[doc(hidden)]
-        #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-        pub enum Ordinary {
-            $( $op = $op.code ),*
-        }
-
-        impl fmt::Display for Ordinary {
-            fn fmt(&self, f: &mut fmt::Formatter) -> core::fmt::Result {
-                match *self {
-                   $(Ordinary::$op => { f.pad(stringify!($op)) }),*
-                }
-            }
-        }
-
-        impl Ordinary {
-            fn with(b: Opcode) -> Self {
-                match b {
-                    $( $op => { Ordinary::$op } ),*
-                    _ => unreachable!("construction of `Ordinary` type from non-ordinary opcode {}", b),
-                }
-            }
-
-            /// Constructs a new [`Ordinary`] from an [`Opcode`].
-            pub fn from_opcode(b: Opcode) -> Option<Self> {
-                match b {
-                    $( $op => { Some(Ordinary::$op) } ),*
-                    _ => None,
-                }
-            }
-        }
-    );
-}
-
-// "Ordinary" opcodes -- should be 61 of these
-ordinary_opcode! {
-    // pushdata
-    OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4,
-    // control flow
-    OP_IF, OP_NOTIF, OP_ELSE, OP_ENDIF, OP_VERIFY,
-    // stack
-    OP_TOALTSTACK, OP_FROMALTSTACK,
-    OP_2DROP, OP_2DUP, OP_3DUP, OP_2OVER, OP_2ROT, OP_2SWAP,
-    OP_DROP, OP_DUP, OP_NIP, OP_OVER, OP_PICK, OP_ROLL, OP_ROT, OP_SWAP, OP_TUCK,
-    OP_IFDUP, OP_DEPTH, OP_SIZE,
-    // equality
-    OP_EQUAL, OP_EQUALVERIFY,
-    // arithmetic
-    OP_1ADD, OP_1SUB, OP_NEGATE, OP_ABS, OP_NOT, OP_0NOTEQUAL,
-    OP_ADD, OP_SUB, OP_BOOLAND, OP_BOOLOR,
-    OP_NUMEQUAL, OP_NUMEQUALVERIFY, OP_NUMNOTEQUAL, OP_LESSTHAN,
-    OP_GREATERTHAN, OP_LESSTHANOREQUAL, OP_GREATERTHANOREQUAL,
-    OP_MIN, OP_MAX, OP_WITHIN,
-    // crypto
-    OP_RIPEMD160, OP_SHA1, OP_SHA256, OP_HASH160, OP_HASH256,
-    OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKSIGVERIFY,
-    OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY,
-    OP_CHECKSIGADD
-}
-
-impl Ordinary {
-    /// Encodes [`Opcode`] as a byte.
-    #[inline]
-    pub fn to_u8(self) -> u8 { self as u8 }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashSet;
-
-    use super::*;
-
-    macro_rules! roundtrip {
-        ($unique:expr, $op:ident) => {
-            assert_eq!($op, Opcode::from($op.to_u8()));
-
-            let s1 = format!("{}", $op);
-            let s2 = format!("{:?}", $op);
-            assert_eq!(s1, s2);
-            assert_eq!(s1, stringify!($op));
-            assert!($unique.insert(s1));
-        };
-    }
-
-    #[test]
-    fn formatting_works() {
-        let op = all::OP_NOP;
-        let s = format!("{:>10}", op);
-        assert_eq!(s, "    OP_NOP");
-    }
-
-    #[test]
-    fn ordinary_op_code() {
-        let ordinary_op = Ordinary::from_opcode(OP_PUSHDATA1).expect("0x4C");
-        assert_eq!(ordinary_op.to_u8(), 0x4C_u8);
-    }
-
-    #[test]
-    fn decode_pushnum() {
-        // Test all possible opcodes
-        // - Sanity check
-        assert_eq!(OP_PUSHNUM_1.code, 0x51_u8);
-        assert_eq!(OP_PUSHNUM_16.code, 0x60_u8);
-        for i in 0x00..=0xff_u8 {
-            let expected = match i {
-                // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
-                0x51..=0x60 => Some(i - 0x50),
-                _ => None,
-            };
-            assert_eq!(Opcode::from(i).decode_pushnum(), expected);
-        }
-
-        // Test the named opcode constants
-        // - This is the OP right before PUSHNUMs start
-        assert!(OP_RESERVED.decode_pushnum().is_none());
-        assert_eq!(OP_PUSHNUM_1.decode_pushnum().expect("pushnum"), 1);
-        assert_eq!(OP_PUSHNUM_2.decode_pushnum().expect("pushnum"), 2);
-        assert_eq!(OP_PUSHNUM_3.decode_pushnum().expect("pushnum"), 3);
-        assert_eq!(OP_PUSHNUM_4.decode_pushnum().expect("pushnum"), 4);
-        assert_eq!(OP_PUSHNUM_5.decode_pushnum().expect("pushnum"), 5);
-        assert_eq!(OP_PUSHNUM_6.decode_pushnum().expect("pushnum"), 6);
-        assert_eq!(OP_PUSHNUM_7.decode_pushnum().expect("pushnum"), 7);
-        assert_eq!(OP_PUSHNUM_8.decode_pushnum().expect("pushnum"), 8);
-        assert_eq!(OP_PUSHNUM_9.decode_pushnum().expect("pushnum"), 9);
-        assert_eq!(OP_PUSHNUM_10.decode_pushnum().expect("pushnum"), 10);
-        assert_eq!(OP_PUSHNUM_11.decode_pushnum().expect("pushnum"), 11);
-        assert_eq!(OP_PUSHNUM_12.decode_pushnum().expect("pushnum"), 12);
-        assert_eq!(OP_PUSHNUM_13.decode_pushnum().expect("pushnum"), 13);
-        assert_eq!(OP_PUSHNUM_14.decode_pushnum().expect("pushnum"), 14);
-        assert_eq!(OP_PUSHNUM_15.decode_pushnum().expect("pushnum"), 15);
-        assert_eq!(OP_PUSHNUM_16.decode_pushnum().expect("pushnum"), 16);
-        // - This is the OP right after PUSHNUMs end
-        assert!(OP_NOP.decode_pushnum().is_none());
-    }
-
-    #[test]
-    fn classify_test() {
-        let op174 = OP_CHECKMULTISIG;
-        assert_eq!(
-            op174.classify(ClassifyContext::Legacy),
-            Class::Ordinary(Ordinary::OP_CHECKMULTISIG)
-        );
-        assert_eq!(op174.classify(ClassifyContext::TapScript), Class::ReturnOp);
-
-        let op175 = OP_CHECKMULTISIGVERIFY;
-        assert_eq!(
-            op175.classify(ClassifyContext::Legacy),
-            Class::Ordinary(Ordinary::OP_CHECKMULTISIGVERIFY)
-        );
-        assert_eq!(op175.classify(ClassifyContext::TapScript), Class::ReturnOp);
-
-        let op186 = OP_CHECKSIGADD;
-        assert_eq!(op186.classify(ClassifyContext::Legacy), Class::ReturnOp);
-        assert_eq!(
-            op186.classify(ClassifyContext::TapScript),
-            Class::Ordinary(Ordinary::OP_CHECKSIGADD)
-        );
-
-        let op187 = OP_RETURN_187;
-        assert_eq!(op187.classify(ClassifyContext::Legacy), Class::ReturnOp);
-        assert_eq!(op187.classify(ClassifyContext::TapScript), Class::SuccessOp);
-    }
-
-    #[test]
-    #[allow(clippy::too_many_lines)] // This is fine, we never need to read it.
-    fn str_roundtrip() {
-        let mut unique = HashSet::new();
-        roundtrip!(unique, OP_PUSHBYTES_0);
-        roundtrip!(unique, OP_PUSHBYTES_1);
-        roundtrip!(unique, OP_PUSHBYTES_2);
-        roundtrip!(unique, OP_PUSHBYTES_3);
-        roundtrip!(unique, OP_PUSHBYTES_4);
-        roundtrip!(unique, OP_PUSHBYTES_5);
-        roundtrip!(unique, OP_PUSHBYTES_6);
-        roundtrip!(unique, OP_PUSHBYTES_7);
-        roundtrip!(unique, OP_PUSHBYTES_8);
-        roundtrip!(unique, OP_PUSHBYTES_9);
-        roundtrip!(unique, OP_PUSHBYTES_10);
-        roundtrip!(unique, OP_PUSHBYTES_11);
-        roundtrip!(unique, OP_PUSHBYTES_12);
-        roundtrip!(unique, OP_PUSHBYTES_13);
-        roundtrip!(unique, OP_PUSHBYTES_14);
-        roundtrip!(unique, OP_PUSHBYTES_15);
-        roundtrip!(unique, OP_PUSHBYTES_16);
-        roundtrip!(unique, OP_PUSHBYTES_17);
-        roundtrip!(unique, OP_PUSHBYTES_18);
-        roundtrip!(unique, OP_PUSHBYTES_19);
-        roundtrip!(unique, OP_PUSHBYTES_20);
-        roundtrip!(unique, OP_PUSHBYTES_21);
-        roundtrip!(unique, OP_PUSHBYTES_22);
-        roundtrip!(unique, OP_PUSHBYTES_23);
-        roundtrip!(unique, OP_PUSHBYTES_24);
-        roundtrip!(unique, OP_PUSHBYTES_25);
-        roundtrip!(unique, OP_PUSHBYTES_26);
-        roundtrip!(unique, OP_PUSHBYTES_27);
-        roundtrip!(unique, OP_PUSHBYTES_28);
-        roundtrip!(unique, OP_PUSHBYTES_29);
-        roundtrip!(unique, OP_PUSHBYTES_30);
-        roundtrip!(unique, OP_PUSHBYTES_31);
-        roundtrip!(unique, OP_PUSHBYTES_32);
-        roundtrip!(unique, OP_PUSHBYTES_33);
-        roundtrip!(unique, OP_PUSHBYTES_34);
-        roundtrip!(unique, OP_PUSHBYTES_35);
-        roundtrip!(unique, OP_PUSHBYTES_36);
-        roundtrip!(unique, OP_PUSHBYTES_37);
-        roundtrip!(unique, OP_PUSHBYTES_38);
-        roundtrip!(unique, OP_PUSHBYTES_39);
-        roundtrip!(unique, OP_PUSHBYTES_40);
-        roundtrip!(unique, OP_PUSHBYTES_41);
-        roundtrip!(unique, OP_PUSHBYTES_42);
-        roundtrip!(unique, OP_PUSHBYTES_43);
-        roundtrip!(unique, OP_PUSHBYTES_44);
-        roundtrip!(unique, OP_PUSHBYTES_45);
-        roundtrip!(unique, OP_PUSHBYTES_46);
-        roundtrip!(unique, OP_PUSHBYTES_47);
-        roundtrip!(unique, OP_PUSHBYTES_48);
-        roundtrip!(unique, OP_PUSHBYTES_49);
-        roundtrip!(unique, OP_PUSHBYTES_50);
-        roundtrip!(unique, OP_PUSHBYTES_51);
-        roundtrip!(unique, OP_PUSHBYTES_52);
-        roundtrip!(unique, OP_PUSHBYTES_53);
-        roundtrip!(unique, OP_PUSHBYTES_54);
-        roundtrip!(unique, OP_PUSHBYTES_55);
-        roundtrip!(unique, OP_PUSHBYTES_56);
-        roundtrip!(unique, OP_PUSHBYTES_57);
-        roundtrip!(unique, OP_PUSHBYTES_58);
-        roundtrip!(unique, OP_PUSHBYTES_59);
-        roundtrip!(unique, OP_PUSHBYTES_60);
-        roundtrip!(unique, OP_PUSHBYTES_61);
-        roundtrip!(unique, OP_PUSHBYTES_62);
-        roundtrip!(unique, OP_PUSHBYTES_63);
-        roundtrip!(unique, OP_PUSHBYTES_64);
-        roundtrip!(unique, OP_PUSHBYTES_65);
-        roundtrip!(unique, OP_PUSHBYTES_66);
-        roundtrip!(unique, OP_PUSHBYTES_67);
-        roundtrip!(unique, OP_PUSHBYTES_68);
-        roundtrip!(unique, OP_PUSHBYTES_69);
-        roundtrip!(unique, OP_PUSHBYTES_70);
-        roundtrip!(unique, OP_PUSHBYTES_71);
-        roundtrip!(unique, OP_PUSHBYTES_72);
-        roundtrip!(unique, OP_PUSHBYTES_73);
-        roundtrip!(unique, OP_PUSHBYTES_74);
-        roundtrip!(unique, OP_PUSHBYTES_75);
-        roundtrip!(unique, OP_PUSHDATA1);
-        roundtrip!(unique, OP_PUSHDATA2);
-        roundtrip!(unique, OP_PUSHDATA4);
-        roundtrip!(unique, OP_PUSHNUM_NEG1);
-        roundtrip!(unique, OP_RESERVED);
-        roundtrip!(unique, OP_PUSHNUM_1);
-        roundtrip!(unique, OP_PUSHNUM_2);
-        roundtrip!(unique, OP_PUSHNUM_3);
-        roundtrip!(unique, OP_PUSHNUM_4);
-        roundtrip!(unique, OP_PUSHNUM_5);
-        roundtrip!(unique, OP_PUSHNUM_6);
-        roundtrip!(unique, OP_PUSHNUM_7);
-        roundtrip!(unique, OP_PUSHNUM_8);
-        roundtrip!(unique, OP_PUSHNUM_9);
-        roundtrip!(unique, OP_PUSHNUM_10);
-        roundtrip!(unique, OP_PUSHNUM_11);
-        roundtrip!(unique, OP_PUSHNUM_12);
-        roundtrip!(unique, OP_PUSHNUM_13);
-        roundtrip!(unique, OP_PUSHNUM_14);
-        roundtrip!(unique, OP_PUSHNUM_15);
-        roundtrip!(unique, OP_PUSHNUM_16);
-        roundtrip!(unique, OP_NOP);
-        roundtrip!(unique, OP_VER);
-        roundtrip!(unique, OP_IF);
-        roundtrip!(unique, OP_NOTIF);
-        roundtrip!(unique, OP_VERIF);
-        roundtrip!(unique, OP_VERNOTIF);
-        roundtrip!(unique, OP_ELSE);
-        roundtrip!(unique, OP_ENDIF);
-        roundtrip!(unique, OP_VERIFY);
-        roundtrip!(unique, OP_RETURN);
-        roundtrip!(unique, OP_TOALTSTACK);
-        roundtrip!(unique, OP_FROMALTSTACK);
-        roundtrip!(unique, OP_2DROP);
-        roundtrip!(unique, OP_2DUP);
-        roundtrip!(unique, OP_3DUP);
-        roundtrip!(unique, OP_2OVER);
-        roundtrip!(unique, OP_2ROT);
-        roundtrip!(unique, OP_2SWAP);
-        roundtrip!(unique, OP_IFDUP);
-        roundtrip!(unique, OP_DEPTH);
-        roundtrip!(unique, OP_DROP);
-        roundtrip!(unique, OP_DUP);
-        roundtrip!(unique, OP_NIP);
-        roundtrip!(unique, OP_OVER);
-        roundtrip!(unique, OP_PICK);
-        roundtrip!(unique, OP_ROLL);
-        roundtrip!(unique, OP_ROT);
-        roundtrip!(unique, OP_SWAP);
-        roundtrip!(unique, OP_TUCK);
-        roundtrip!(unique, OP_CAT);
-        roundtrip!(unique, OP_SUBSTR);
-        roundtrip!(unique, OP_LEFT);
-        roundtrip!(unique, OP_RIGHT);
-        roundtrip!(unique, OP_SIZE);
-        roundtrip!(unique, OP_INVERT);
-        roundtrip!(unique, OP_AND);
-        roundtrip!(unique, OP_OR);
-        roundtrip!(unique, OP_XOR);
-        roundtrip!(unique, OP_EQUAL);
-        roundtrip!(unique, OP_EQUALVERIFY);
-        roundtrip!(unique, OP_RESERVED1);
-        roundtrip!(unique, OP_RESERVED2);
-        roundtrip!(unique, OP_1ADD);
-        roundtrip!(unique, OP_1SUB);
-        roundtrip!(unique, OP_2MUL);
-        roundtrip!(unique, OP_2DIV);
-        roundtrip!(unique, OP_NEGATE);
-        roundtrip!(unique, OP_ABS);
-        roundtrip!(unique, OP_NOT);
-        roundtrip!(unique, OP_0NOTEQUAL);
-        roundtrip!(unique, OP_ADD);
-        roundtrip!(unique, OP_SUB);
-        roundtrip!(unique, OP_MUL);
-        roundtrip!(unique, OP_DIV);
-        roundtrip!(unique, OP_MOD);
-        roundtrip!(unique, OP_LSHIFT);
-        roundtrip!(unique, OP_RSHIFT);
-        roundtrip!(unique, OP_BOOLAND);
-        roundtrip!(unique, OP_BOOLOR);
-        roundtrip!(unique, OP_NUMEQUAL);
-        roundtrip!(unique, OP_NUMEQUALVERIFY);
-        roundtrip!(unique, OP_NUMNOTEQUAL);
-        roundtrip!(unique, OP_LESSTHAN);
-        roundtrip!(unique, OP_GREATERTHAN);
-        roundtrip!(unique, OP_LESSTHANOREQUAL);
-        roundtrip!(unique, OP_GREATERTHANOREQUAL);
-        roundtrip!(unique, OP_MIN);
-        roundtrip!(unique, OP_MAX);
-        roundtrip!(unique, OP_WITHIN);
-        roundtrip!(unique, OP_RIPEMD160);
-        roundtrip!(unique, OP_SHA1);
-        roundtrip!(unique, OP_SHA256);
-        roundtrip!(unique, OP_HASH160);
-        roundtrip!(unique, OP_HASH256);
-        roundtrip!(unique, OP_CODESEPARATOR);
-        roundtrip!(unique, OP_CHECKSIG);
-        roundtrip!(unique, OP_CHECKSIGVERIFY);
-        roundtrip!(unique, OP_CHECKMULTISIG);
-        roundtrip!(unique, OP_CHECKMULTISIGVERIFY);
-        roundtrip!(unique, OP_NOP1);
-        roundtrip!(unique, OP_CLTV);
-        roundtrip!(unique, OP_CSV);
-        roundtrip!(unique, OP_NOP4);
-        roundtrip!(unique, OP_NOP5);
-        roundtrip!(unique, OP_NOP6);
-        roundtrip!(unique, OP_NOP7);
-        roundtrip!(unique, OP_NOP8);
-        roundtrip!(unique, OP_NOP9);
-        roundtrip!(unique, OP_NOP10);
-        roundtrip!(unique, OP_CHECKSIGADD);
-        roundtrip!(unique, OP_RETURN_187);
-        roundtrip!(unique, OP_RETURN_188);
-        roundtrip!(unique, OP_RETURN_189);
-        roundtrip!(unique, OP_RETURN_190);
-        roundtrip!(unique, OP_RETURN_191);
-        roundtrip!(unique, OP_RETURN_192);
-        roundtrip!(unique, OP_RETURN_193);
-        roundtrip!(unique, OP_RETURN_194);
-        roundtrip!(unique, OP_RETURN_195);
-        roundtrip!(unique, OP_RETURN_196);
-        roundtrip!(unique, OP_RETURN_197);
-        roundtrip!(unique, OP_RETURN_198);
-        roundtrip!(unique, OP_RETURN_199);
-        roundtrip!(unique, OP_RETURN_200);
-        roundtrip!(unique, OP_RETURN_201);
-        roundtrip!(unique, OP_RETURN_202);
-        roundtrip!(unique, OP_RETURN_203);
-        roundtrip!(unique, OP_RETURN_204);
-        roundtrip!(unique, OP_RETURN_205);
-        roundtrip!(unique, OP_RETURN_206);
-        roundtrip!(unique, OP_RETURN_207);
-        roundtrip!(unique, OP_RETURN_208);
-        roundtrip!(unique, OP_RETURN_209);
-        roundtrip!(unique, OP_RETURN_210);
-        roundtrip!(unique, OP_RETURN_211);
-        roundtrip!(unique, OP_RETURN_212);
-        roundtrip!(unique, OP_RETURN_213);
-        roundtrip!(unique, OP_RETURN_214);
-        roundtrip!(unique, OP_RETURN_215);
-        roundtrip!(unique, OP_RETURN_216);
-        roundtrip!(unique, OP_RETURN_217);
-        roundtrip!(unique, OP_RETURN_218);
-        roundtrip!(unique, OP_RETURN_219);
-        roundtrip!(unique, OP_RETURN_220);
-        roundtrip!(unique, OP_RETURN_221);
-        roundtrip!(unique, OP_RETURN_222);
-        roundtrip!(unique, OP_RETURN_223);
-        roundtrip!(unique, OP_RETURN_224);
-        roundtrip!(unique, OP_RETURN_225);
-        roundtrip!(unique, OP_RETURN_226);
-        roundtrip!(unique, OP_RETURN_227);
-        roundtrip!(unique, OP_RETURN_228);
-        roundtrip!(unique, OP_RETURN_229);
-        roundtrip!(unique, OP_RETURN_230);
-        roundtrip!(unique, OP_RETURN_231);
-        roundtrip!(unique, OP_RETURN_232);
-        roundtrip!(unique, OP_RETURN_233);
-        roundtrip!(unique, OP_RETURN_234);
-        roundtrip!(unique, OP_RETURN_235);
-        roundtrip!(unique, OP_RETURN_236);
-        roundtrip!(unique, OP_RETURN_237);
-        roundtrip!(unique, OP_RETURN_238);
-        roundtrip!(unique, OP_RETURN_239);
-        roundtrip!(unique, OP_RETURN_240);
-        roundtrip!(unique, OP_RETURN_241);
-        roundtrip!(unique, OP_RETURN_242);
-        roundtrip!(unique, OP_RETURN_243);
-        roundtrip!(unique, OP_RETURN_244);
-        roundtrip!(unique, OP_RETURN_245);
-        roundtrip!(unique, OP_RETURN_246);
-        roundtrip!(unique, OP_RETURN_247);
-        roundtrip!(unique, OP_RETURN_248);
-        roundtrip!(unique, OP_RETURN_249);
-        roundtrip!(unique, OP_RETURN_250);
-        roundtrip!(unique, OP_RETURN_251);
-        roundtrip!(unique, OP_RETURN_252);
-        roundtrip!(unique, OP_RETURN_253);
-        roundtrip!(unique, OP_RETURN_254);
-        roundtrip!(unique, OP_INVALIDOPCODE);
-        assert_eq!(unique.len(), 256);
+/// Read the following byte as a length, and read the following
+/// bytes as a push of that length.
+pub const OP_PUSHDATA1: u8 = 0x4c;
+
+/// Read the following 2 bytes as a little-endian length, and read the following
+/// bytes as a push of that length.
+pub const OP_PUSHDATA2: u8 = 0x4d;
+
+/// Read the following 4 bytes as a little-endian length, and read the following
+/// bytes as a push of that length.
+pub const OP_PUSHDATA4: u8 = 0x4e;
+
+/// Format a byte as a script opcode.
+pub fn fmt_opcode(op: u8, f: &mut fmt::Formatter) -> fmt::Result {
+    match op {
+        0x00 => f.write_str("OP_0"),
+        0x01..=0x4b => write!(f, "OP_PUSHBYTES_{}", op),
+        0x4c => f.write_str("OP_PUSHDATA1"),
+        0x4d => f.write_str("OP_PUSHDATA2"),
+        0x4e => f.write_str("OP_PUSHDATA4"),
+        0x4f => f.write_str("OP_1NEGATE"),
+        0x50 => f.write_str("OP_RESERVED"),
+        0x51..=0x60 => write!(f, "OP_{}", op - 0x50),
+        0x61 => f.write_str("OP_NOP"),
+        0x62 => f.write_str("OP_VER"),
+        0x63 => f.write_str("OP_IF"),
+        0x64 => f.write_str("OP_NOTIF"),
+        0x65 => f.write_str("OP_VERIF"),
+        0x66 => f.write_str("OP_VERNOTIF"),
+        0x67 => f.write_str("OP_ELSE"),
+        0x68 => f.write_str("OP_ENDIF"),
+        0x69 => f.write_str("OP_VERIFY"),
+        0x6a => f.write_str("OP_RETURN"),
+        0x6b => f.write_str("OP_TOALTSTACK"),
+        0x6c => f.write_str("OP_FROMALTSTACK"),
+        0x6d => f.write_str("OP_2DROP"),
+        0x6e => f.write_str("OP_2DUP"),
+        0x6f => f.write_str("OP_3DUP"),
+        0x70 => f.write_str("OP_2OVER"),
+        0x71 => f.write_str("OP_2ROT"),
+        0x72 => f.write_str("OP_2SWAP"),
+        0x73 => f.write_str("OP_IFDUP"),
+        0x74 => f.write_str("OP_DEPTH"),
+        0x75 => f.write_str("OP_DROP"),
+        0x76 => f.write_str("OP_DUP"),
+        0x77 => f.write_str("OP_NIP"),
+        0x78 => f.write_str("OP_OVER"),
+        0x79 => f.write_str("OP_PICK"),
+        0x7a => f.write_str("OP_ROLL"),
+        0x7b => f.write_str("OP_ROT"),
+        0x7c => f.write_str("OP_SWAP"),
+        0x7d => f.write_str("OP_TUCK"),
+        0x7e => f.write_str("OP_CAT"),
+        0x7f => f.write_str("OP_SUBSTR"),
+        0x80 => f.write_str("OP_LEFT"),
+        0x81 => f.write_str("OP_RIGHT"),
+        0x82 => f.write_str("OP_SIZE"),
+        0x83 => f.write_str("OP_INVERT"),
+        0x84 => f.write_str("OP_AND"),
+        0x85 => f.write_str("OP_OR"),
+        0x86 => f.write_str("OP_XOR"),
+        0x87 => f.write_str("OP_EQUAL"),
+        0x88 => f.write_str("OP_EQUALVERIFY"),
+        0x89 => f.write_str("OP_RESERVED1"),
+        0x8a => f.write_str("OP_RESERVED2"),
+        0x8b => f.write_str("OP_1ADD"),
+        0x8c => f.write_str("OP_1SUB"),
+        0x8d => f.write_str("OP_2MUL"),
+        0x8e => f.write_str("OP_2DIV"),
+        0x8f => f.write_str("OP_NEGATE"),
+        0x90 => f.write_str("OP_ABS"),
+        0x91 => f.write_str("OP_NOT"),
+        0x92 => f.write_str("OP_0NOTEQUAL"),
+        0x93 => f.write_str("OP_ADD"),
+        0x94 => f.write_str("OP_SUB"),
+        0x95 => f.write_str("OP_MUL"),
+        0x96 => f.write_str("OP_DIV"),
+        0x97 => f.write_str("OP_MOD"),
+        0x98 => f.write_str("OP_LSHIFT"),
+        0x99 => f.write_str("OP_RSHIFT"),
+        0x9a => f.write_str("OP_BOOLAND"),
+        0x9b => f.write_str("OP_BOOLOR"),
+        0x9c => f.write_str("OP_NUMEQUAL"),
+        0x9d => f.write_str("OP_NUMEQUALVERIFY"),
+        0x9e => f.write_str("OP_NUMNOTEQUAL"),
+        0x9f => f.write_str("OP_LESSTHAN"),
+        0xa0 => f.write_str("OP_GREATERTHAN"),
+        0xa1 => f.write_str("OP_LESSTHANOREQUAL"),
+        0xa2 => f.write_str("OP_GREATERTHANOREQUAL"),
+        0xa3 => f.write_str("OP_MIN"),
+        0xa4 => f.write_str("OP_MAX"),
+        0xa5 => f.write_str("OP_WITHIN"),
+        0xa6 => f.write_str("OP_RIPEMD160"),
+        0xa7 => f.write_str("OP_SHA1"),
+        0xa8 => f.write_str("OP_SHA256"),
+        0xa9 => f.write_str("OP_HASH160"),
+        0xaa => f.write_str("OP_HASH256"),
+        0xab => f.write_str("OP_CODESEPARATOR"),
+        0xac => f.write_str("OP_CHECKSIG"),
+        0xad => f.write_str("OP_CHECKSIGVERIFY"),
+        0xae => f.write_str("OP_CHECKMULTISIG"),
+        0xaf => f.write_str("OP_CHECKMULTISIGVERIFY"),
+        0xb1 => f.write_str("OP_CLTV"),
+        0xb2 => f.write_str("OP_CSV"),
+        0xb0..=0xb9 => write!(f, "OP_NOP{}", op - 0xb0 + 1),
+        0xba => f.write_str("OP_CHECKSIGADD"),
+        0xbb..=0xfe => write!(f, "OP_RETURN_{}", op),
+        0xff => f.write_str("OP_INVALIDOPCODE"),
     }
 }
diff --git a/primitives/src/pow.rs b/primitives/src/pow.rs
index b7f5fc46ce..75f4d14322 100644
--- a/primitives/src/pow.rs
+++ b/primitives/src/pow.rs
@@ -2,8 +2,11 @@
 
 //! Proof-of-work related integer types.
 
+use core::convert::Infallible;
 use core::fmt;
 
+use internals::write_err;
+
 /// Encoding of 256-bit target as 32-bit float.
 ///
 /// This is used to encode a target into the block header. Satoshi made this part of consensus code
@@ -18,7 +21,7 @@ use core::fmt;
 /// `CompactTarget` and `Target` is lossy *in both directions* (there are multiple `CompactTarget`
 /// values that map to the same `Target` value). Ordering and equality for this type are defined in
 /// terms of the underlying `u32`.
-#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct CompactTarget(u32);
 
@@ -29,25 +32,103 @@ impl CompactTarget {
 
     /// Returns the consensus encoded `u32` representation of this [`CompactTarget`].
     #[inline]
-    pub fn to_consensus(self) -> u32 { self.0 }
+    pub const fn to_consensus(self) -> u32 { self.0 }
+
+    /// Gets the hex representation of this [`CompactTarget`].
+    #[cfg(feature = "alloc")]
+    #[inline]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `format!(\"{var:x}\")` instead")]
+    pub fn to_hex(self) -> alloc::string::String { alloc::format!("{:x}", self) }
 }
 
 impl fmt::LowerHex for CompactTarget {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
 }
-#[cfg(feature = "alloc")]
-internals::impl_to_hex_from_lower_hex!(CompactTarget, |compact_target: &CompactTarget| {
-    8 - compact_target.0.leading_zeros() as usize / 4
-});
 
 impl fmt::UpperHex for CompactTarget {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
 }
 
+encoding::encoder_newtype! {
+    /// The encoder for the [`CompactTarget`] type.
+    pub struct CompactTargetEncoder(encoding::ArrayEncoder<4>);
+}
+
+impl encoding::Encodable for CompactTarget {
+    type Encoder<'e> = CompactTargetEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        CompactTargetEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_consensus().to_le_bytes(),
+        ))
+    }
+}
+
+/// The decoder for the [`CompactTarget`] type.
+pub struct CompactTargetDecoder(encoding::ArrayDecoder<4>);
+
+impl CompactTargetDecoder {
+    /// Constructs a new [`CompactTarget`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for CompactTargetDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for CompactTargetDecoder {
+    type Output = CompactTarget;
+    type Error = CompactTargetDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end()?);
+        Ok(CompactTarget::from_consensus(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for CompactTarget {
+    type Decoder = CompactTargetDecoder;
+    fn decoder() -> Self::Decoder { CompactTargetDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `CompactTarget`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CompactTargetDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for CompactTargetDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<encoding::UnexpectedEofError> for CompactTargetDecoderError {
+    fn from(e: encoding::UnexpectedEofError) -> Self { Self(e) }
+}
+
+impl fmt::Display for CompactTargetDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "sequence decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CompactTargetDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::format;
+
     use super::*;
 
     #[test]
@@ -61,6 +142,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn compact_target_formatting() {
         let compact_target = CompactTarget::from_consensus(0x1d00_ffff);
         assert_eq!(format!("{:x}", compact_target), "1d00ffff");
diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index df4e2a3d1b..d75cc6a1c8 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use core::marker::PhantomData;
 use core::ops::{
     Bound, Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
 };
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use encoding::{BytesEncoder, CompactSizeEncoder, Encodable, Encoder2};
 
 use super::ScriptBuf;
 use crate::prelude::{Box, ToOwned, Vec};
@@ -52,7 +54,7 @@ internals::transparent_newtype! {
     /// # Hexadecimal strings
     ///
     /// Scripts are consensus encoded with a length prefix and as a result of this in some places in
-    /// the eccosystem one will encounter hex strings that include the prefix while in other places
+    /// the ecosystem one will encounter hex strings that include the prefix while in other places
     /// the prefix is excluded. To support parsing and formatting scripts as hex we provide a bunch
     /// of different APIs and trait implementations. Please see [`examples/script.rs`] for a
     /// thorough example of all the APIs.
@@ -62,9 +64,9 @@ internals::transparent_newtype! {
     /// * [CScript definition](https://github.com/bitcoin/bitcoin/blob/d492dc1cdaabdc52b0766bf4cba4bd73178325d0/src/script/script.h#L410)
     ///
     #[derive(PartialOrd, Ord, PartialEq, Eq, Hash)]
-    pub struct Script([u8]);
+    pub struct Script<T>(PhantomData<T>, [u8]);
 
-    impl Script {
+    impl<T> Script<T> {
         /// Treat byte slice as `Script`
         pub const fn from_bytes(bytes: &_) -> &Self;
 
@@ -77,19 +79,19 @@ internals::transparent_newtype! {
     }
 }
 
-impl Default for &Script {
+impl<T: 'static> Default for &Script<T> {
     #[inline]
     fn default() -> Self { Script::new() }
 }
 
-impl ToOwned for Script {
-    type Owned = ScriptBuf;
+impl<T> ToOwned for Script<T> {
+    type Owned = ScriptBuf<T>;
 
     #[inline]
     fn to_owned(&self) -> Self::Owned { ScriptBuf::from_bytes(self.to_vec()) }
 }
 
-impl Script {
+impl<T> Script<T> {
     /// Constructs a new empty script.
     #[inline]
     pub const fn new() -> &'static Self { Self::from_bytes(&[]) }
@@ -98,13 +100,13 @@ impl Script {
     ///
     /// This is just the script bytes **not** consensus encoding (which includes a length prefix).
     #[inline]
-    pub const fn as_bytes(&self) -> &[u8] { &self.0 }
+    pub const fn as_bytes(&self) -> &[u8] { &self.1 }
 
     /// Returns the script data as a mutable byte slice.
     ///
     /// This is just the script bytes **not** consensus encoding (which includes a length prefix).
     #[inline]
-    pub fn as_mut_bytes(&mut self) -> &mut [u8] { &mut self.0 }
+    pub fn as_mut_bytes(&mut self) -> &mut [u8] { &mut self.1 }
 
     /// Returns a copy of the script data.
     ///
@@ -114,7 +116,7 @@ impl Script {
 
     /// Returns a copy of the script data.
     #[inline]
-    #[deprecated(since = "TBD", note = "use to_vec instead")]
+    #[deprecated(since = "0.101.0", note = "use to_vec instead")]
     pub fn to_bytes(&self) -> Vec<u8> { self.to_vec() }
 
     /// Returns the length in bytes of the script.
@@ -128,7 +130,7 @@ impl Script {
     /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
     #[must_use]
     #[inline]
-    pub fn into_script_buf(self: Box<Self>) -> ScriptBuf {
+    pub fn into_script_buf(self: Box<Self>) -> ScriptBuf<T> {
         let rw = Box::into_raw(self) as *mut [u8];
         // SAFETY: copied from `std`
         // The pointer was just created from a box without deallocating
@@ -137,10 +139,41 @@ impl Script {
         let inner = unsafe { Box::from_raw(rw) };
         ScriptBuf::from_bytes(Vec::from(inner))
     }
+
+    /// Gets the hex representation of this script.
+    ///
+    /// # Returns
+    ///
+    /// Just the script bytes in hexadecimal **not** consensus encoding of the script i.e., the
+    /// string will not include a length prefix.
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    #[inline]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `format!(\"{var:x}\")` instead")]
+    pub fn to_hex(&self) -> alloc::string::String { alloc::format!("{:x}", self) }
+}
+
+encoding::encoder_newtype! {
+    /// The encoder for the [`Script<T>`] type.
+    pub struct ScriptEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+}
+
+impl<T> Encodable for Script<T> {
+    type Encoder<'a>
+        = ScriptEncoder<'a>
+    where
+        Self: 'a;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        ScriptEncoder(Encoder2::new(
+            CompactSizeEncoder::new(self.as_bytes().len()),
+            BytesEncoder::without_length_prefix(self.as_bytes()),
+        ))
+    }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for &'a Script {
+impl<'a, T> Arbitrary<'a> for &'a Script<T> {
     #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let v = <&'a [u8]>::arbitrary(u)?;
@@ -152,7 +185,7 @@ macro_rules! delegate_index {
     ($($type:ty),* $(,)?) => {
         $(
             /// Script subslicing operation - read [slicing safety](#slicing-safety)!
-            impl Index<$type> for Script {
+            impl<T> Index<$type> for Script<T> {
                 type Output = Self;
 
                 #[inline]
@@ -176,7 +209,11 @@ delegate_index!(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    // All tests should compile and pass no matter which script type you put here.
+    type Script = super::super::ScriptSig;
+
+    #[cfg(feature = "alloc")]
+    use alloc::{borrow::ToOwned, vec};
 
     #[test]
     fn script_from_bytes() {
@@ -231,4 +268,18 @@ mod tests {
         assert_eq!(script[1..=3].as_bytes(), &[2, 3, 4]);
         assert_eq!(script[..=2].as_bytes(), &[1, 2, 3]);
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn encode() {
+        // Consensus encoding includes the length of the encoded data
+        // (compact size encoded length prefix).
+        let consensus_encoded: [u8; 6] = [0x05, 1, 2, 3, 4, 5];
+
+        // `from_bytes` does not expect the prefix.
+        let script = Script::from_bytes(&consensus_encoded[1..]);
+
+        let got = encoding::encode_to_vec(script);
+        assert_eq!(got, consensus_encoded);
+    }
 }
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 012b4f4448..173a7c2c66 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -4,19 +4,17 @@
 
 mod borrowed;
 mod owned;
+mod tag;
 
 use core::cmp::Ordering;
-use core::convert::Infallible;
 use core::fmt;
+#[cfg(feature = "serde")]
+use core::marker::PhantomData;
 
-use hashes::{hash160, sha256};
 #[cfg(feature = "hex")]
-use hex::DisplayHex;
+use hex_unstable::DisplayHex;
 use internals::script::{self, PushDataLenLen};
 
-#[allow(clippy::wildcard_imports)]
-use crate::opcodes::all::*;
-use crate::opcodes::{self, Opcode};
 use crate::prelude::rc::Rc;
 #[cfg(target_has_atomic = "ptr")]
 use crate::prelude::sync::Arc;
@@ -25,320 +23,241 @@ use crate::prelude::{Borrow, BorrowMut, Box, Cow, ToOwned, Vec};
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
-    borrowed::Script,
-    owned::ScriptBuf,
+    borrowed::{Script, ScriptEncoder},
+    owned::{ScriptBuf, ScriptBufDecoder, ScriptBufDecoderError},
+    tag::{Tag, RedeemScriptTag, ScriptPubKeyTag, ScriptSigTag, TapScriptTag, WitnessScriptTag},
+};
+#[doc(inline)]
+pub use crate::hash_types::{
+    RedeemScriptSizeError, ScriptHash, WScriptHash, WitnessScriptSizeError,
 };
 
-/// The maximum allowed redeem script size for a P2SH output.
-pub const MAX_REDEEM_SCRIPT_SIZE: usize = 520;
-/// The maximum allowed redeem script size of the witness script.
-pub const MAX_WITNESS_SCRIPT_SIZE: usize = 10_000;
+/// A P2SH redeem script.
+pub type RedeemScriptBuf = ScriptBuf<RedeemScriptTag>;
 
-hashes::hash_newtype! {
-    /// A 160-bit hash of Bitcoin Script bytecode.
-    ///
-    /// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
-    /// uses 256-bit hash and hashes a semantically different script. Thus, this type cannot
-    /// represent it.
-    pub struct ScriptHash(hash160::Hash);
+/// A reference to a P2SH redeem script.
+pub type RedeemScript = Script<RedeemScriptTag>;
 
-    /// SegWit (256-bit) version of a Bitcoin Script bytecode hash.
-    ///
-    /// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
-    /// looks similar to this one also being SHA256, however, they hash semantically different
-    /// scripts and have reversed representations, so this type cannot be used for both.
-    pub struct WScriptHash(sha256::Hash);
-}
+/// A reference to a `scriptPubKey` (locking script).
+pub type ScriptPubKey = Script<ScriptPubKeyTag>;
 
-#[cfg(feature = "hex")]
-hashes::impl_hex_for_newtype!(ScriptHash, WScriptHash);
-#[cfg(not(feature = "hex"))]
-hashes::impl_debug_only_for_newtype!(ScriptHash, WScriptHash);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(ScriptHash, WScriptHash);
-
-impl ScriptHash {
-    /// Constructs a new `ScriptHash` after first checking the script size.
-    ///
-    /// # 520-byte limitation on serialized script size
-    ///
-    /// > As a consequence of the requirement for backwards compatibility the serialized script is
-    /// > itself subject to the same rules as any other PUSHDATA operation, including the rule that
-    /// > no data greater than 520 bytes may be pushed to the stack. Thus it is not possible to
-    /// > spend a P2SH output if the redemption script it refers to is >520 bytes in length.
-    ///
-    /// ref: [BIP-16](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size)
-    #[inline]
-    pub fn from_script(redeem_script: &Script) -> Result<Self, RedeemScriptSizeError> {
-        if redeem_script.len() > MAX_REDEEM_SCRIPT_SIZE {
-            return Err(RedeemScriptSizeError { size: redeem_script.len() });
-        }
+/// A reference to a script signature (scriptSig).
+pub type ScriptSig = Script<ScriptSigTag>;
 
-        // We've just checked the length
-        Ok(ScriptHash::from_script_unchecked(redeem_script))
-    }
+/// A `scriptPubKey` (locking script).
+pub type ScriptPubKeyBuf = ScriptBuf<ScriptPubKeyTag>;
 
-    /// Constructs a new `ScriptHash` from any script irrespective of script size.
-    ///
-    /// If you hash a script that exceeds 520 bytes in size and use it to create a P2SH output
-    /// then the output will be unspendable (see [BIP-16]).
-    ///
-    /// [BIP-16]: <https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size>
-    #[inline]
-    pub fn from_script_unchecked(script: &Script) -> Self {
-        ScriptHash(hash160::Hash::hash(script.as_bytes()))
-    }
-}
+/// A `scriptPubKey` decoder.
+pub type ScriptPubKeyBufDecoder = ScriptBufDecoder<ScriptPubKeyTag>;
 
-impl WScriptHash {
-    /// Constructs a new `WScriptHash` after first checking the script size.
-    ///
-    /// # 10,000-byte limit on the witness script
-    ///
-    /// > The witnessScript (≤ 10,000 bytes) is popped off the initial witness stack. SHA256 of the
-    /// > witnessScript must match the 32-byte witness program.
-    ///
-    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
-    #[inline]
-    pub fn from_script(witness_script: &Script) -> Result<Self, WitnessScriptSizeError> {
-        if witness_script.len() > MAX_WITNESS_SCRIPT_SIZE {
-            return Err(WitnessScriptSizeError { size: witness_script.len() });
-        }
+/// A script signature (scriptSig).
+pub type ScriptSigBuf = ScriptBuf<ScriptSigTag>;
 
-        // We've just checked the length
-        Ok(WScriptHash::from_script_unchecked(witness_script))
-    }
+/// A `scriptSig` decoder.
+pub type ScriptSigBufDecoder = ScriptBufDecoder<ScriptSigTag>;
 
-    /// Constructs a new `WScriptHash` from any script irrespective of script size.
-    ///
-    /// If you hash a script that exceeds 10,000 bytes in size and use it to create a Segwit
-    /// output then the output will be unspendable (see [BIP-141]).
-    ///
-    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
-    #[inline]
-    pub fn from_script_unchecked(script: &Script) -> Self {
-        WScriptHash(sha256::Hash::hash(script.as_bytes()))
-    }
+/// A Segwit v1 Taproot script.
+pub type TapScriptBuf = ScriptBuf<TapScriptTag>;
+
+/// A reference to a Segwit v1 Taproot script.
+pub type TapScript = Script<TapScriptTag>;
+
+/// A Segwit v0 witness script.
+pub type WitnessScriptBuf = ScriptBuf<WitnessScriptTag>;
+
+/// A reference to a Segwit v0 witness script.
+pub type WitnessScript = Script<WitnessScriptTag>;
+
+/// The maximum allowed redeem script size for a P2SH output.
+pub const MAX_REDEEM_SCRIPT_SIZE: usize = 520;
+/// The maximum allowed redeem script size of the witness script.
+pub const MAX_WITNESS_SCRIPT_SIZE: usize = 10_000;
+
+/// Either a redeem script or a Segwit version 0 scriptpubkey.
+///
+/// In the case of P2SH-wrapped Segwit version outputs, we take a Segwit scriptPubKey
+/// and put it in a redeem script slot. The Bitcoin script interpreter has special
+/// logic to handle this case, which is reflected in our API in several methods
+/// relating to P2SH and signature hashing. These methods take either a normal
+/// P2SH redeem script, or a Segwit version 0 scriptpubkey.
+///
+/// Segwit version 1 (Taproot) and higher do **not** support P2SH-wrapping, and such
+/// scriptPubKeys should not be used with this trait.
+pub trait ScriptHashableTag: sealed::Sealed {}
+
+impl ScriptHashableTag for RedeemScriptTag {}
+impl ScriptHashableTag for ScriptPubKeyTag {}
+
+mod sealed {
+    pub trait Sealed {}
+    impl Sealed for super::RedeemScriptTag {}
+    impl Sealed for super::ScriptPubKeyTag {}
 }
 
-impl TryFrom<ScriptBuf> for ScriptHash {
+impl<T: ScriptHashableTag> TryFrom<ScriptBuf<T>> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
     #[inline]
-    fn try_from(redeem_script: ScriptBuf) -> Result<Self, Self::Error> {
+    fn try_from(redeem_script: ScriptBuf<T>) -> Result<Self, Self::Error> {
         Self::from_script(&redeem_script)
     }
 }
 
-impl TryFrom<&ScriptBuf> for ScriptHash {
+impl<T: ScriptHashableTag> TryFrom<&ScriptBuf<T>> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
     #[inline]
-    fn try_from(redeem_script: &ScriptBuf) -> Result<Self, Self::Error> {
+    fn try_from(redeem_script: &ScriptBuf<T>) -> Result<Self, Self::Error> {
         Self::from_script(redeem_script)
     }
 }
 
-impl TryFrom<&Script> for ScriptHash {
+impl<T: ScriptHashableTag> TryFrom<&Script<T>> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
     #[inline]
-    fn try_from(redeem_script: &Script) -> Result<Self, Self::Error> {
+    fn try_from(redeem_script: &Script<T>) -> Result<Self, Self::Error> {
         Self::from_script(redeem_script)
     }
 }
 
-impl TryFrom<ScriptBuf> for WScriptHash {
+impl TryFrom<WitnessScriptBuf> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
     #[inline]
-    fn try_from(witness_script: ScriptBuf) -> Result<Self, Self::Error> {
+    fn try_from(witness_script: WitnessScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(&witness_script)
     }
 }
 
-impl TryFrom<&ScriptBuf> for WScriptHash {
+impl TryFrom<&WitnessScriptBuf> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
     #[inline]
-    fn try_from(witness_script: &ScriptBuf) -> Result<Self, Self::Error> {
+    fn try_from(witness_script: &WitnessScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(witness_script)
     }
 }
 
-impl TryFrom<&Script> for WScriptHash {
+impl TryFrom<&WitnessScript> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
     #[inline]
-    fn try_from(witness_script: &Script) -> Result<Self, Self::Error> {
+    fn try_from(witness_script: &WitnessScript) -> Result<Self, Self::Error> {
         Self::from_script(witness_script)
     }
 }
 
-/// Error while hashing a redeem script.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RedeemScriptSizeError {
-    /// Invalid redeem script size (cannot exceed 520 bytes).
-    size: usize,
-}
-
-impl RedeemScriptSizeError {
-    /// Returns the invalid redeem script size.
-    pub fn invalid_size(&self) -> usize { self.size }
-}
-
-impl From<Infallible> for RedeemScriptSizeError {
-    #[inline]
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl fmt::Display for RedeemScriptSizeError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "redeem script size exceeds {} bytes: {}", MAX_REDEEM_SCRIPT_SIZE, self.size)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for RedeemScriptSizeError {}
-
-/// Error while hashing a witness script.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct WitnessScriptSizeError {
-    /// Invalid witness script size (cannot exceed 10,000 bytes).
-    size: usize,
-}
-
-impl WitnessScriptSizeError {
-    /// Returns the invalid witness script size.
-    pub fn invalid_size(&self) -> usize { self.size }
-}
-
-impl From<Infallible> for WitnessScriptSizeError {
-    #[inline]
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl fmt::Display for WitnessScriptSizeError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "witness script size exceeds {} bytes: {}", MAX_WITNESS_SCRIPT_SIZE, self.size)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for WitnessScriptSizeError {}
-
-// We keep all the `Script` and `ScriptBuf` impls together since its easier to see side-by-side.
+// We keep all the `Script` and `ScriptBuf` impls together since it's easier to see side-by-side.
 
-impl From<ScriptBuf> for Box<Script> {
+impl<T> From<ScriptBuf<T>> for Box<Script<T>> {
     #[inline]
-    fn from(v: ScriptBuf) -> Self { v.into_boxed_script() }
+    fn from(v: ScriptBuf<T>) -> Self { v.into_boxed_script() }
 }
 
-impl From<ScriptBuf> for Cow<'_, Script> {
+impl<T> From<ScriptBuf<T>> for Cow<'_, Script<T>> {
     #[inline]
-    fn from(value: ScriptBuf) -> Self { Cow::Owned(value) }
+    fn from(value: ScriptBuf<T>) -> Self { Cow::Owned(value) }
 }
 
-impl<'a> From<Cow<'a, Script>> for ScriptBuf {
+impl<'a, T> From<Cow<'a, Script<T>>> for ScriptBuf<T> {
     #[inline]
-    fn from(value: Cow<'a, Script>) -> Self {
+    fn from(value: Cow<'a, Script<T>>) -> Self {
         match value {
             Cow::Owned(owned) => owned,
-            Cow::Borrowed(borrwed) => borrwed.into(),
+            Cow::Borrowed(borrowed) => borrowed.into(),
         }
     }
 }
 
-impl<'a> From<Cow<'a, Script>> for Box<Script> {
+impl<'a, T> From<Cow<'a, Script<T>>> for Box<Script<T>> {
     #[inline]
-    fn from(value: Cow<'a, Script>) -> Self {
+    fn from(value: Cow<'a, Script<T>>) -> Self {
         match value {
             Cow::Owned(owned) => owned.into(),
-            Cow::Borrowed(borrwed) => borrwed.into(),
+            Cow::Borrowed(borrowed) => borrowed.into(),
         }
     }
 }
 
-impl<'a> From<&'a Script> for Box<Script> {
+impl<'a, T> From<&'a Script<T>> for Box<Script<T>> {
     #[inline]
-    fn from(value: &'a Script) -> Self { value.to_owned().into() }
+    fn from(value: &'a Script<T>) -> Self { value.to_owned().into() }
 }
 
-impl<'a> From<&'a Script> for ScriptBuf {
+impl<'a, T> From<&'a Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn from(value: &'a Script) -> Self { value.to_owned() }
+    fn from(value: &'a Script<T>) -> Self { value.to_owned() }
 }
 
-impl<'a> From<&'a Script> for Cow<'a, Script> {
+impl<'a, T> From<&'a Script<T>> for Cow<'a, Script<T>> {
     #[inline]
-    fn from(value: &'a Script) -> Self { Cow::Borrowed(value) }
+    fn from(value: &'a Script<T>) -> Self { Cow::Borrowed(value) }
 }
 
 /// Note: This will fail to compile on old Rust for targets that don't support atomics
 #[cfg(target_has_atomic = "ptr")]
-impl<'a> From<&'a Script> for Arc<Script> {
+impl<'a, T> From<&'a Script<T>> for Arc<Script<T>> {
     #[inline]
-    fn from(value: &'a Script) -> Self { Script::from_arc_bytes(Arc::from(value.as_bytes())) }
+    fn from(value: &'a Script<T>) -> Self { Script::from_arc_bytes(Arc::from(value.as_bytes())) }
 }
 
-impl<'a> From<&'a Script> for Rc<Script> {
+impl<'a, T> From<&'a Script<T>> for Rc<Script<T>> {
     #[inline]
-    fn from(value: &'a Script) -> Self { Script::from_rc_bytes(Rc::from(value.as_bytes())) }
+    fn from(value: &'a Script<T>) -> Self { Script::from_rc_bytes(Rc::from(value.as_bytes())) }
 }
 
-impl From<Vec<u8>> for ScriptBuf {
+impl<T> From<Vec<u8>> for ScriptBuf<T> {
     #[inline]
-    fn from(v: Vec<u8>) -> Self { ScriptBuf::from_bytes(v) }
+    fn from(v: Vec<u8>) -> Self { Self::from_bytes(v) }
 }
 
-impl From<ScriptBuf> for Vec<u8> {
+impl<T> From<ScriptBuf<T>> for Vec<u8> {
     #[inline]
-    fn from(v: ScriptBuf) -> Self { v.into_bytes() }
+    fn from(v: ScriptBuf<T>) -> Self { v.into_bytes() }
 }
 
-impl AsRef<Script> for Script {
+impl<T> AsRef<Self> for Script<T> {
     #[inline]
     fn as_ref(&self) -> &Self { self }
 }
 
-impl AsRef<Script> for ScriptBuf {
+impl<T> AsRef<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn as_ref(&self) -> &Script { self }
+    fn as_ref(&self) -> &Script<T> { self }
 }
 
-impl AsRef<[u8]> for Script {
+impl<T> AsRef<[u8]> for Script<T> {
     #[inline]
     fn as_ref(&self) -> &[u8] { self.as_bytes() }
 }
 
-impl AsRef<[u8]> for ScriptBuf {
+impl<T> AsRef<[u8]> for ScriptBuf<T> {
     #[inline]
     fn as_ref(&self) -> &[u8] { self.as_bytes() }
 }
 
-impl AsMut<Script> for Script {
+impl<T> AsMut<Self> for Script<T> {
     #[inline]
     fn as_mut(&mut self) -> &mut Self { self }
 }
 
-impl AsMut<Script> for ScriptBuf {
+impl<T> AsMut<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn as_mut(&mut self) -> &mut Script { self }
+    fn as_mut(&mut self) -> &mut Script<T> { self }
 }
 
-impl AsMut<[u8]> for Script {
+impl<T> AsMut<[u8]> for Script<T> {
     #[inline]
     fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
 }
 
-impl AsMut<[u8]> for ScriptBuf {
+impl<T> AsMut<[u8]> for ScriptBuf<T> {
     #[inline]
     fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
 }
 
-impl fmt::Debug for Script {
+impl<T> fmt::Debug for Script<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("Script(")?;
         fmt::Display::fmt(self, f)?;
@@ -346,12 +265,12 @@ impl fmt::Debug for Script {
     }
 }
 
-impl fmt::Debug for ScriptBuf {
+impl<T> fmt::Debug for ScriptBuf<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(self.as_script(), f) }
 }
 
-impl fmt::Display for Script {
+impl<T> fmt::Display for Script<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // This has to be a macro because it needs to break the loop
         macro_rules! read_push_data_len {
@@ -371,15 +290,13 @@ impl fmt::Display for Script {
         let mut at_least_one = false;
         // `iter` needs to be borrowed in `read_push_data_len`, so we have to use `while let` instead
         // of `for`.
-        while let Some(byte) = iter.next() {
-            let opcode = Opcode::from(*byte);
+        while let Some(byte) = iter.next().copied() {
+            use crate::opcodes::{OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4};
 
-            let data_len = if let opcodes::Class::PushBytes(n) =
-                opcode.classify(opcodes::ClassifyContext::Legacy)
-            {
-                n as usize
+            let data_len = if byte <= 75 {
+                usize::from(byte)
             } else {
-                match opcode {
+                match byte {
                     OP_PUSHDATA1 => {
                         // side effects: may write and break from the loop
                         read_push_data_len!(&mut iter, PushDataLenLen::One, f)
@@ -402,11 +319,7 @@ impl fmt::Display for Script {
                 at_least_one = true;
             }
             // Write the opcode
-            if opcode == OP_PUSHBYTES_0 {
-                f.write_str("OP_0")?;
-            } else {
-                write!(f, "{:?}", opcode)?;
-            }
+            crate::opcodes::fmt_opcode(byte, f)?;
             // Write any pushdata
             if data_len > 0 {
                 f.write_str(" ")?;
@@ -424,33 +337,27 @@ impl fmt::Display for Script {
     }
 }
 
-impl fmt::Display for ScriptBuf {
+impl<T> fmt::Display for ScriptBuf<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self.as_script(), f) }
 }
 
 #[cfg(feature = "hex")]
-impl fmt::LowerHex for Script {
+impl<T> fmt::LowerHex for Script<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::LowerHex::fmt(&self.as_bytes().as_hex(), f)
     }
 }
-#[cfg(feature = "alloc")]
-#[cfg(feature = "hex")]
-internals::impl_to_hex_from_lower_hex!(Script, |script: &Self| script.len() * 2);
 
 #[cfg(feature = "hex")]
-impl fmt::LowerHex for ScriptBuf {
+impl<T> fmt::LowerHex for ScriptBuf<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self.as_script(), f) }
 }
-#[cfg(feature = "alloc")]
-#[cfg(feature = "hex")]
-internals::impl_to_hex_from_lower_hex!(ScriptBuf, |script_buf: &Self| script_buf.len() * 2);
 
 #[cfg(feature = "hex")]
-impl fmt::UpperHex for Script {
+impl<T> fmt::UpperHex for Script<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::UpperHex::fmt(&self.as_bytes().as_hex(), f)
@@ -458,47 +365,47 @@ impl fmt::UpperHex for Script {
 }
 
 #[cfg(feature = "hex")]
-impl fmt::UpperHex for ScriptBuf {
+impl<T> fmt::UpperHex for ScriptBuf<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(self.as_script(), f) }
 }
 
-impl Borrow<Script> for ScriptBuf {
+impl<T> Borrow<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn borrow(&self) -> &Script { self }
+    fn borrow(&self) -> &Script<T> { self }
 }
 
-impl BorrowMut<Script> for ScriptBuf {
+impl<T> BorrowMut<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn borrow_mut(&mut self) -> &mut Script { self }
+    fn borrow_mut(&mut self) -> &mut Script<T> { self }
 }
 
-impl PartialEq<ScriptBuf> for Script {
+impl<T: PartialEq> PartialEq<ScriptBuf<T>> for Script<T> {
     #[inline]
-    fn eq(&self, other: &ScriptBuf) -> bool { self.eq(other.as_script()) }
+    fn eq(&self, other: &ScriptBuf<T>) -> bool { self.eq(other.as_script()) }
 }
 
-impl PartialEq<Script> for ScriptBuf {
+impl<T: PartialEq> PartialEq<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn eq(&self, other: &Script) -> bool { self.as_script().eq(other) }
+    fn eq(&self, other: &Script<T>) -> bool { self.as_script().eq(other) }
 }
 
-impl PartialOrd<Script> for ScriptBuf {
+impl<T: PartialOrd> PartialOrd<Script<T>> for ScriptBuf<T> {
     #[inline]
-    fn partial_cmp(&self, other: &Script) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &Script<T>) -> Option<Ordering> {
         self.as_script().partial_cmp(other)
     }
 }
 
-impl PartialOrd<ScriptBuf> for Script {
+impl<T: PartialOrd> PartialOrd<ScriptBuf<T>> for Script<T> {
     #[inline]
-    fn partial_cmp(&self, other: &ScriptBuf) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &ScriptBuf<T>) -> Option<Ordering> {
         self.partial_cmp(other.as_script())
     }
 }
 
 #[cfg(feature = "serde")]
-impl serde::Serialize for Script {
+impl<T> serde::Serialize for Script<T> {
     /// User-facing serialization for `Script`.
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -514,14 +421,14 @@ impl serde::Serialize for Script {
 
 /// Can only deserialize borrowed bytes.
 #[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for &'de Script {
+impl<'de, T> serde::Deserialize<'de> for &'de Script<T> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        struct Visitor;
-        impl<'de> serde::de::Visitor<'de> for Visitor {
-            type Value = &'de Script;
+        struct Visitor<T>(PhantomData<T>);
+        impl<'de, T: 'de> serde::de::Visitor<'de> for Visitor<T> {
+            type Value = &'de Script<T>;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                 formatter.write_str("borrowed bytes")
@@ -543,12 +450,12 @@ impl<'de> serde::Deserialize<'de> for &'de Script {
             ));
         }
 
-        deserializer.deserialize_bytes(Visitor)
+        deserializer.deserialize_bytes(Visitor(PhantomData))
     }
 }
 
 #[cfg(feature = "serde")]
-impl serde::Serialize for ScriptBuf {
+impl<T> serde::Serialize for ScriptBuf<T> {
     /// User-facing serialization for `Script`.
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -559,19 +466,17 @@ impl serde::Serialize for ScriptBuf {
 }
 
 #[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for ScriptBuf {
+impl<'de, T> serde::Deserialize<'de> for ScriptBuf<T> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
         use core::fmt::Formatter;
 
-        use hex::FromHex;
-
         if deserializer.is_human_readable() {
-            struct Visitor;
-            impl serde::de::Visitor<'_> for Visitor {
-                type Value = ScriptBuf;
+            struct Visitor<T>(PhantomData<T>);
+            impl<T> serde::de::Visitor<'_> for Visitor<T> {
+                type Value = ScriptBuf<T>;
 
                 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
                     formatter.write_str("a script hex")
@@ -581,16 +486,16 @@ impl<'de> serde::Deserialize<'de> for ScriptBuf {
                 where
                     E: serde::de::Error,
                 {
-                    let v = Vec::from_hex(v).map_err(E::custom)?;
+                    let v = hex::decode_to_vec(v).map_err(E::custom)?;
                     Ok(ScriptBuf::from(v))
                 }
             }
-            deserializer.deserialize_str(Visitor)
+            deserializer.deserialize_str(Visitor(PhantomData))
         } else {
-            struct BytesVisitor;
+            struct BytesVisitor<T>(PhantomData<T>);
 
-            impl serde::de::Visitor<'_> for BytesVisitor {
-                type Value = ScriptBuf;
+            impl<T> serde::de::Visitor<'_> for BytesVisitor<T> {
+                type Value = ScriptBuf<T>;
 
                 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
                     formatter.write_str("a script Vec<u8>")
@@ -610,15 +515,24 @@ impl<'de> serde::Deserialize<'de> for ScriptBuf {
                     Ok(ScriptBuf::from(v))
                 }
             }
-            deserializer.deserialize_byte_buf(BytesVisitor)
+            deserializer.deserialize_byte_buf(BytesVisitor(PhantomData))
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::{format, vec};
+
+    use hashes::{hash160, sha256};
+
     use super::*;
 
+    // All tests should compile and pass no matter which script type you put here.
+    type Script = ScriptSig;
+    type ScriptBuf = ScriptSigBuf;
+
     #[test]
     fn scriptbuf_from_vec_u8() {
         let vec = vec![0x51, 0x52, 0x53];
@@ -705,87 +619,95 @@ mod tests {
 
     #[test]
     fn script_hash_from_script() {
-        let script = Script::from_bytes(&[0x51; 520]);
+        let script = RedeemScript::from_bytes(&[0x51; 520]);
         assert!(ScriptHash::from_script(script).is_ok());
 
-        let script = Script::from_bytes(&[0x51; 521]);
+        let script = RedeemScript::from_bytes(&[0x51; 521]);
         assert!(ScriptHash::from_script(script).is_err());
     }
 
     #[test]
     fn script_hash_from_script_unchecked() {
-        let script = Script::from_bytes(&[0x51; 521]);
-        let hash = ScriptHash::from_script_unchecked(script);
-        assert_eq!(hash, ScriptHash(hash160::Hash::hash(script.as_bytes())));
+        let script = WitnessScript::from_bytes(&[0x51; 521]);
+
+        let got = ScriptHash::from_script_unchecked(script);
+        let want =
+            ScriptHash::from_byte_array(hash160::Hash::hash(script.as_bytes()).to_byte_array());
+
+        assert_eq!(got, want);
     }
 
     #[test]
     fn wscript_hash_from_script() {
-        let script = Script::from_bytes(&[0x51; 10_000]);
+        let script = WitnessScript::from_bytes(&[0x51; 10_000]);
         assert!(WScriptHash::from_script(script).is_ok());
 
-        let script = Script::from_bytes(&[0x51; 10_001]);
+        let script = WitnessScript::from_bytes(&[0x51; 10_001]);
         assert!(WScriptHash::from_script(script).is_err());
     }
 
     #[test]
     fn wscript_hash_from_script_unchecked() {
-        let script = Script::from_bytes(&[0x51; 10_001]);
-        let hash = WScriptHash::from_script_unchecked(script);
-        assert_eq!(hash, WScriptHash(sha256::Hash::hash(script.as_bytes())));
+        let script = WitnessScript::from_bytes(&[0x51; 10_001]);
+
+        let got = WScriptHash::from_script_unchecked(script);
+        let want =
+            WScriptHash::from_byte_array(sha256::Hash::hash(script.as_bytes()).to_byte_array());
+
+        assert_eq!(got, want);
     }
 
     #[test]
-    fn try_from_scriptbuf_for_scripthash() {
-        let script = ScriptBuf::from(vec![0x51; 520]);
+    fn try_from_scriptpubkeybuf_for_scripthash() {
+        let script = ScriptPubKeyBuf::from(vec![0x51; 520]);
         assert!(ScriptHash::try_from(script).is_ok());
 
-        let script = ScriptBuf::from(vec![0x51; 521]);
+        let script = ScriptPubKeyBuf::from(vec![0x51; 521]);
         assert!(ScriptHash::try_from(script).is_err());
     }
 
     #[test]
-    fn try_from_scriptbuf_ref_for_scripthash() {
-        let script = ScriptBuf::from(vec![0x51; 520]);
+    fn try_from_scriptpubkeybuf_ref_for_scripthash() {
+        let script = ScriptPubKeyBuf::from(vec![0x51; 520]);
         assert!(ScriptHash::try_from(&script).is_ok());
 
-        let script = ScriptBuf::from(vec![0x51; 521]);
+        let script = ScriptPubKeyBuf::from(vec![0x51; 521]);
         assert!(ScriptHash::try_from(&script).is_err());
     }
 
     #[test]
     fn try_from_script_for_scripthash() {
-        let script = Script::from_bytes(&[0x51; 520]);
+        let script = RedeemScript::from_bytes(&[0x51; 520]);
         assert!(ScriptHash::try_from(script).is_ok());
 
-        let script = Script::from_bytes(&[0x51; 521]);
+        let script = RedeemScript::from_bytes(&[0x51; 521]);
         assert!(ScriptHash::try_from(script).is_err());
     }
 
     #[test]
     fn try_from_scriptbuf_for_wscript_hash() {
-        let script = ScriptBuf::from(vec![0x51; 10_000]);
+        let script = WitnessScriptBuf::from(vec![0x51; 10_000]);
         assert!(WScriptHash::try_from(script).is_ok());
 
-        let script = ScriptBuf::from(vec![0x51; 10_001]);
+        let script = WitnessScriptBuf::from(vec![0x51; 10_001]);
         assert!(WScriptHash::try_from(script).is_err());
     }
 
     #[test]
     fn try_from_scriptbuf_ref_for_wscript_hash() {
-        let script = ScriptBuf::from(vec![0x51; 10_000]);
+        let script = WitnessScriptBuf::from(vec![0x51; 10_000]);
         assert!(WScriptHash::try_from(&script).is_ok());
 
-        let script = ScriptBuf::from(vec![0x51; 10_001]);
+        let script = WitnessScriptBuf::from(vec![0x51; 10_001]);
         assert!(WScriptHash::try_from(&script).is_err());
     }
 
     #[test]
     fn try_from_script_for_wscript_hash() {
-        let script = Script::from_bytes(&[0x51; 10_000]);
+        let script = WitnessScript::from_bytes(&[0x51; 10_000]);
         assert!(WScriptHash::try_from(script).is_ok());
 
-        let script = Script::from_bytes(&[0x51; 10_001]);
+        let script = WitnessScript::from_bytes(&[0x51; 10_001]);
         assert!(WScriptHash::try_from(script).is_err());
     }
 
@@ -802,6 +724,21 @@ mod tests {
         assert!(!format!("{:?}", script).is_empty());
     }
 
+    #[test]
+    fn script_display_pushdata() {
+        // OP_PUSHDATA1
+        let script = Script::from_bytes(&[0x4c, 0x02, 0xab, 0xcd]);
+        assert_eq!(format!("{}", script), "OP_PUSHDATA1 abcd");
+
+        // OP_PUSHDATA2
+        let script = Script::from_bytes(&[0x4d, 0x02, 0x00, 0x12, 0x34]);
+        assert_eq!(format!("{}", script), "OP_PUSHDATA2 1234");
+
+        // OP_PUSHDATA4
+        let script = Script::from_bytes(&[0x4e, 0x02, 0x00, 0x00, 0x00, 0x56, 0x78]);
+        assert_eq!(format!("{}", script), "OP_PUSHDATA4 5678");
+    }
+
     #[test]
     fn scriptbuf_display() {
         let script_buf = ScriptBuf::from(vec![0x00, 0xa1, 0xb2]);
@@ -825,8 +762,7 @@ mod tests {
 
     #[test]
     fn cow_scriptbuf_to_script() {
-        let script_buf = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
-        let cow_owned: Cow<Script> = Cow::Owned(script_buf.clone());
+        let cow_owned: Cow<Script> = Cow::Owned(ScriptBuf::from(vec![0x51, 0x52, 0x53]));
         let script: &Script = cow_owned.borrow();
         assert_eq!(script.as_bytes(), &[0x51, 0x52, 0x53]);
     }
@@ -864,7 +800,7 @@ mod tests {
 
     #[test]
     fn redeem_script_size_error() {
-        let script = ScriptBuf::from(vec![0x51; 521]);
+        let script = RedeemScriptBuf::from(vec![0x51; 521]);
         let result = ScriptHash::try_from(script);
 
         let err = result.unwrap_err();
@@ -876,7 +812,7 @@ mod tests {
 
     #[test]
     fn witness_script_size_error() {
-        let script = ScriptBuf::from(vec![0x51; 10_001]);
+        let script = WitnessScriptBuf::from(vec![0x51; 10_001]);
         let result = WScriptHash::try_from(script);
 
         let err = result.unwrap_err();
@@ -927,7 +863,7 @@ mod tests {
     #[cfg(feature = "hex")]
     fn script_to_hex() {
         let script = Script::from_bytes(&[0xa1, 0xb2, 0xc3]);
-        let hex = script.to_hex();
+        let hex = alloc::format!("{script:x}");
         assert_eq!(hex, "a1b2c3");
     }
 
@@ -936,7 +872,7 @@ mod tests {
     #[cfg(feature = "hex")]
     fn scriptbuf_to_hex() {
         let script = ScriptBuf::from_bytes(vec![0xa1, 0xb2, 0xc3]);
-        let hex = script.to_hex();
+        let hex = alloc::format!("{script:x}");
         assert_eq!(hex, "a1b2c3");
     }
 }
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 70a3cbb874..ea8dbc15c7 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -1,9 +1,14 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use core::convert::Infallible;
+use core::fmt;
+use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use encoding::{ByteVecDecoder, ByteVecDecoderError, Decodable, Decoder};
+use internals::write_err;
 
 use super::Script;
 use crate::prelude::{Box, Vec};
@@ -19,17 +24,22 @@ use crate::prelude::{Box, Vec};
 /// # Hexadecimal strings
 ///
 /// Scripts are consensus encoded with a length prefix and as a result of this in some places in the
-/// eccosystem one will encounter hex strings that include the prefix while in other places the
+/// ecosystem one will encounter hex strings that include the prefix while in other places the
 /// prefix is excluded. To support parsing and formatting scripts as hex we provide a bunch of
 /// different APIs and trait implementations. Please see [`examples/script.rs`] for a thorough
 /// example of all the APIs.
 ///
 /// [`examples/script.rs`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/script.rs>
 /// [deref coercions]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion
-#[derive(Default, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct ScriptBuf(Vec<u8>);
+///
+/// # Panics
+///
+/// `ScriptBuf` is backed by [`Vec`] and inherits its panic behavior. This means that attempting to
+/// construct scripts larger than `isize::MAX` bytes will panic.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct ScriptBuf<T>(PhantomData<T>, Vec<u8>);
 
-impl ScriptBuf {
+impl<T> ScriptBuf<T> {
     /// Constructs a new empty script.
     #[inline]
     pub const fn new() -> Self { Self::from_bytes(Vec::new()) }
@@ -39,15 +49,15 @@ impl ScriptBuf {
     /// This method doesn't (re)allocate. `bytes` is just the script bytes **not** consensus
     /// encoding (i.e no length prefix).
     #[inline]
-    pub const fn from_bytes(bytes: Vec<u8>) -> Self { Self(bytes) }
+    pub const fn from_bytes(bytes: Vec<u8>) -> Self { Self(PhantomData, bytes) }
 
     /// Returns a reference to unsized script.
     #[inline]
-    pub fn as_script(&self) -> &Script { Script::from_bytes(&self.0) }
+    pub fn as_script(&self) -> &Script<T> { Script::from_bytes(&self.1) }
 
     /// Returns a mutable reference to unsized script.
     #[inline]
-    pub fn as_mut_script(&mut self) -> &mut Script { Script::from_bytes_mut(&mut self.0) }
+    pub fn as_mut_script(&mut self) -> &mut Script<T> { Script::from_bytes_mut(&mut self.1) }
 
     /// Converts the script into a byte vector.
     ///
@@ -57,7 +67,7 @@ impl ScriptBuf {
     ///
     /// Just the script bytes **not** consensus encoding (which includes a length prefix).
     #[inline]
-    pub fn into_bytes(self) -> Vec<u8> { self.0 }
+    pub fn into_bytes(self) -> Vec<u8> { self.1 }
 
     /// Converts this `ScriptBuf` into a [boxed](Box) [`Script`].
     ///
@@ -67,15 +77,13 @@ impl ScriptBuf {
     /// reallocation can be avoided.
     #[must_use]
     #[inline]
-    pub fn into_boxed_script(self) -> Box<Script> {
+    pub fn into_boxed_script(self) -> Box<Script<T>> {
         Script::from_boxed_bytes(self.into_bytes().into_boxed_slice())
     }
 
     /// Constructs a new empty script with at least the specified capacity.
     #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        ScriptBuf::from_bytes(Vec::with_capacity(capacity))
-    }
+    pub fn with_capacity(capacity: usize) -> Self { Self::from_bytes(Vec::with_capacity(capacity)) }
 
     /// Pre-allocates at least `additional_len` bytes if needed.
     ///
@@ -88,7 +96,7 @@ impl ScriptBuf {
     ///
     /// Panics if the new capacity exceeds `isize::MAX bytes`.
     #[inline]
-    pub fn reserve(&mut self, additional_len: usize) { self.0.reserve(additional_len); }
+    pub fn reserve(&mut self, additional_len: usize) { self.1.reserve(additional_len); }
 
     /// Pre-allocates exactly `additional_len` bytes if needed.
     ///
@@ -104,38 +112,115 @@ impl ScriptBuf {
     ///
     /// Panics if the new capacity exceeds `isize::MAX bytes`.
     #[inline]
-    pub fn reserve_exact(&mut self, additional_len: usize) { self.0.reserve_exact(additional_len); }
+    pub fn reserve_exact(&mut self, additional_len: usize) { self.1.reserve_exact(additional_len); }
 
     /// Returns the number of **bytes** available for writing without reallocation.
     ///
     /// It is guaranteed that `script.capacity() >= script.len()` always holds.
     #[inline]
-    pub fn capacity(&self) -> usize { self.0.capacity() }
+    pub fn capacity(&self) -> usize { self.1.capacity() }
+
+    /// Gets the hex representation of this script.
+    ///
+    /// # Returns
+    ///
+    /// Just the script bytes in hexadecimal **not** consensus encoding of the script i.e., the
+    /// string will not include a length prefix.
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    #[inline]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `format!(\"{var:x}\")` instead")]
+    pub fn to_hex(&self) -> alloc::string::String { alloc::format!("{:x}", self) }
+}
+
+// Cannot derive due to generics.
+impl<T> Default for ScriptBuf<T> {
+    fn default() -> Self { Self(PhantomData, Vec::new()) }
 }
 
-impl Deref for ScriptBuf {
-    type Target = Script;
+impl<T> Deref for ScriptBuf<T> {
+    type Target = Script<T>;
 
     #[inline]
     fn deref(&self) -> &Self::Target { self.as_script() }
 }
 
-impl DerefMut for ScriptBuf {
+impl<T> DerefMut for ScriptBuf<T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_script() }
 }
 
+/// The decoder for the [`ScriptBuf`] type.
+pub struct ScriptBufDecoder<T>(ByteVecDecoder, PhantomData<T>);
+
+impl<T> ScriptBufDecoder<T> {
+    /// Constructs a new [`ScriptBuf`] decoder.
+    pub const fn new() -> Self { Self(ByteVecDecoder::new(), PhantomData) }
+}
+
+impl<T> Default for ScriptBufDecoder<T> {
+    fn default() -> Self { Self::new() }
+}
+
+impl<T> Decoder for ScriptBufDecoder<T> {
+    type Output = ScriptBuf<T>;
+    type Error = ScriptBufDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> { Ok(ScriptBuf::from_bytes(self.0.end()?)) }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl<T> Decodable for ScriptBuf<T> {
+    type Decoder = ScriptBufDecoder<T>;
+    fn decoder() -> Self::Decoder { ScriptBufDecoder(ByteVecDecoder::new(), PhantomData) }
+}
+
+/// An error consensus decoding a `ScriptBuf<T>`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScriptBufDecoderError(ByteVecDecoderError);
+
+impl From<Infallible> for ScriptBufDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<ByteVecDecoderError> for ScriptBufDecoderError {
+    fn from(e: ByteVecDecoderError) -> Self { Self(e) }
+}
+
+impl fmt::Display for ScriptBufDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write_err!(f, "decoder error"; self.0) }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ScriptBufDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
 #[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for ScriptBuf {
+impl<'a, T> Arbitrary<'a> for ScriptBuf<T> {
     #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let v = Vec::<u8>::arbitrary(u)?;
-        Ok(ScriptBuf::from_bytes(v))
+        Ok(Self::from_bytes(v))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    // All tests should compile and pass no matter which script type you put here.
+    type ScriptBuf = super::super::ScriptSigBuf;
+
+    #[cfg(feature = "alloc")]
+    use alloc::vec;
+
     use super::*;
 
     #[test]
@@ -155,11 +240,10 @@ mod tests {
 
     #[test]
     fn script_buf_as_mut_script() {
-        let bytes = vec![1, 2, 3];
-        let mut script = ScriptBuf::from_bytes(bytes.clone());
+        let mut script = ScriptBuf::from_bytes(vec![1, 2, 3]);
         let script_mut_ref = script.as_mut_script();
         script_mut_ref.as_mut_bytes()[0] = 4;
-        assert_eq!(script.as_mut_bytes(), vec![4, 2, 3]);
+        assert_eq!(script.as_mut_bytes(), &[4, 2, 3]);
     }
 
     #[test]
@@ -197,4 +281,31 @@ mod tests {
         script.reserve_exact(10);
         assert!(script.capacity() >= 10);
     }
+
+    #[test]
+    fn script_consensus_decode_empty() {
+        let bytes = vec![0_u8];
+        let mut push = bytes.as_slice();
+        let mut decoder = ScriptBuf::decoder();
+        decoder.push_bytes(&mut push).unwrap();
+
+        let got = decoder.end().unwrap();
+        let want = ScriptBuf::new();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn script_consensus_decode_empty_with_more_data() {
+        // An empty script sig with a bunch of unrelated data at the end.
+        let bytes = vec![0x00_u8, 0xff, 0xff, 0xff, 0xff];
+        let mut push = bytes.as_slice();
+        let mut decoder = ScriptBuf::decoder();
+        decoder.push_bytes(&mut push).unwrap();
+
+        let got = decoder.end().unwrap();
+        let want = ScriptBuf::new();
+
+        assert_eq!(got, want);
+    }
 }
diff --git a/primitives/src/script/tag.rs b/primitives/src/script/tag.rs
new file mode 100644
index 0000000000..d5d5162bcb
--- /dev/null
+++ b/primitives/src/script/tag.rs
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Script tags.
+//!
+//! Tags are used to differentiate the different kinds of scripts that appear
+//! in Bitcoin transactions.
+
+/// Sealed trait representing a type of script.
+pub trait Tag {}
+
+/// A P2SH redeem script.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum RedeemScriptTag {}
+impl Tag for RedeemScriptTag {}
+
+/// A script signature (scriptSig).
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum ScriptSigTag {}
+impl Tag for ScriptSigTag {}
+
+/// A script public key (scriptPubKey).
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum ScriptPubKeyTag {}
+impl Tag for ScriptPubKeyTag {}
+
+/// A Segwit v1 Taproot script.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum TapScriptTag {}
+impl Tag for TapScriptTag {}
+
+/// A Segwit v0 witness script.
+#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum WitnessScriptTag {}
+impl Tag for WitnessScriptTag {}
diff --git a/primitives/src/taproot.rs b/primitives/src/taproot.rs
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 10176ef767..a796e5ced4 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -10,35 +10,48 @@
 //!
 //! This module provides the structures and functions needed to support transactions.
 
-#[cfg(feature = "alloc")]
-use core::cmp;
-#[cfg(feature = "alloc")]
-#[cfg(feature = "hex")]
 use core::convert::Infallible;
 use core::fmt;
+#[cfg(feature = "alloc")]
+use core::{cmp, mem};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use encoding::{ArrayEncoder, BytesEncoder, Encodable, Encoder2, UnexpectedEofError};
+#[cfg(feature = "alloc")]
+use encoding::{
+    CompactSizeEncoder, Decodable, Decoder, Decoder2, Decoder3, Encoder, Encoder3, Encoder6,
+    SliceEncoder, VecDecoder, VecDecoderError,
+};
+#[cfg(feature = "alloc")]
 use hashes::sha256d;
+use internals::array::ArrayExt as _;
 #[cfg(feature = "alloc")]
 use internals::compact_size;
-#[cfg(feature = "hex")]
 use internals::write_err;
+#[cfg(feature = "serde")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "hex")]
-use units::parse;
-#[cfg(feature = "alloc")]
-use units::{Amount, Weight};
+use units::parse_int;
 
 #[cfg(feature = "alloc")]
-use crate::locktime::absolute;
+use crate::amount::{AmountDecoder, AmountEncoder};
+#[cfg(feature = "alloc")]
+use crate::locktime::absolute::{LockTimeDecoder, LockTimeDecoderError, LockTimeEncoder};
 #[cfg(feature = "alloc")]
 use crate::prelude::Vec;
 #[cfg(feature = "alloc")]
-use crate::script::ScriptBuf;
+use crate::script::{ScriptEncoder, ScriptPubKeyBufDecoder, ScriptSigBufDecoder};
+#[cfg(feature = "alloc")]
+use crate::sequence::{SequenceDecoder, SequenceEncoder};
 #[cfg(feature = "alloc")]
-use crate::sequence::Sequence;
+use crate::witness::{WitnessDecoder, WitnessDecoderError, WitnessEncoder};
 #[cfg(feature = "alloc")]
-use crate::witness::Witness;
+use crate::{absolute, Amount, ScriptPubKeyBuf, ScriptSigBuf, Sequence, Weight, Witness};
+
+#[rustfmt::skip]            // Keep public re-exports separate.
+#[doc(inline)]
+pub use crate::hash_types::{Ntxid, Txid, Wtxid, BlockHashDecoder, BlockHashDecoderError, TxMerkleNodeDecoder, TxMerkleNodeDecoderError};
 
 /// Bitcoin transaction.
 ///
@@ -50,19 +63,19 @@ use crate::witness::Witness;
 ///
 /// # Bitcoin Core References
 ///
-/// * [CTtransaction definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L279)
+/// * [CTransaction definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L279)
 ///
 /// # Serialization notes
 ///
 /// If any inputs have nonempty witnesses, the entire transaction is serialized
-/// in the post-BIP141 SegWit format which includes a list of witnesses. If all
-/// inputs have empty witnesses, the transaction is serialized in the pre-BIP141
+/// in the post-BIP-0141 SegWit format which includes a list of witnesses. If all
+/// inputs have empty witnesses, the transaction is serialized in the pre-BIP-0141
 /// format.
 ///
 /// There is one major exception to this: to avoid deserialization ambiguity,
-/// if the transaction has no inputs, it is serialized in the BIP141 style. Be
+/// if the transaction has no inputs, it is serialized in the BIP-0141 style. Be
 /// aware that this differs from the transaction format in PSBT, which _never_
-/// uses BIP141. (Ordinarily there is no conflict, since in PSBT transactions
+/// uses BIP-0141. (Ordinarily there is no conflict, since in PSBT transactions
 /// are always unsigned and therefore their inputs have empty witnesses.)
 ///
 /// The specific ambiguity is that SegWit uses the flag bytes `0001` where an old
@@ -74,7 +87,7 @@ use crate::witness::Witness;
 ///
 /// However, in protocols where transactions may legitimately have 0 inputs, e.g.
 /// when parties are cooperatively funding a transaction, the "00 means SegWit"
-/// heuristic does not work. Since SegWit requires such a transaction be encoded
+/// heuristic does not work. Since SegWit requires such a transaction to be encoded
 /// in the original transaction format (since it has no inputs and therefore
 /// no input witnesses), a traditionally encoded transaction may have the `0001`
 /// SegWit flag in it, which confuses most SegWit parsers including the one in
@@ -96,22 +109,21 @@ use crate::witness::Witness;
 /// before this change, so users should not notice any breakage (here) when
 /// transitioning from 0.29 to 0.30.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg(feature = "alloc")]
 pub struct Transaction {
-    /// The protocol version, is currently expected to be 1, 2 (BIP 68) or 3 (BIP 431).
+    /// The protocol version, is currently expected to be 1, 2 (BIP-0068) or 3 (BIP-0431).
     pub version: Version,
     /// Block height or timestamp. Transaction cannot be included in a block until this height/time.
     ///
     /// # Relevant BIPs
     ///
-    /// * [BIP-65 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
-    /// * [BIP-113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
+    /// * [BIP-0065 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+    /// * [BIP-0113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
     pub lock_time: absolute::LockTime,
     /// List of transaction inputs.
-    pub input: Vec<TxIn>,
+    pub inputs: Vec<TxIn>,
     /// List of transaction outputs.
-    pub output: Vec<TxOut>,
+    pub outputs: Vec<TxOut>,
 }
 
 #[cfg(feature = "alloc")]
@@ -120,43 +132,32 @@ impl Transaction {
     /// Maximum transaction weight for Bitcoin Core 25.0.
     pub const MAX_STANDARD_WEIGHT: Weight = Weight::from_wu(400_000);
 
-    /// Returns a reference to the transaction inputs.
-    #[inline]
-    pub fn inputs(&self) -> &[TxIn] { &self.input }
-
-    /// Returns a mutable reference to the transaction inputs.
-    #[inline]
-    pub fn inputs_mut(&mut self) -> &mut [TxIn] { &mut self.input }
-
-    /// Returns a reference to the transaction outputs.
-    #[inline]
-    pub fn outputs(&self) -> &[TxOut] { &self.output }
-
-    /// Returns a mutable reference to the transaction outputs.
-    #[inline]
-    pub fn outputs_mut(&mut self) -> &mut [TxOut] { &mut self.output }
-
     /// Computes a "normalized TXID" which does not include any signatures.
     ///
-    /// This gives a way to identify a transaction that is "the same" as
-    /// another in the sense of having same inputs and outputs.
+    /// This function is needed only for legacy (pre-Segwit or P2SH-wrapped segwit version 0)
+    /// applications. This method clears the `script_sig` field of each input, which in Segwit
+    /// transactions is already empty, so for Segwit transactions the ntxid will be equal to the
+    /// txid, and you should simply use the latter.
+    ///
+    /// This gives a way to identify a transaction that is "the same" as another in the sense of
+    /// having the same inputs and outputs.
     #[doc(alias = "ntxid")]
-    pub fn compute_ntxid(&self) -> sha256d::Hash {
-        let cloned_tx = Transaction {
+    pub fn compute_ntxid(&self) -> Ntxid {
+        let normalized = Self {
             version: self.version,
             lock_time: self.lock_time,
-            input: self
-                .input
+            inputs: self
+                .inputs
                 .iter()
                 .map(|txin| TxIn {
-                    script_sig: ScriptBuf::new(),
+                    script_sig: ScriptSigBuf::new(),
                     witness: Witness::default(),
                     ..*txin
                 })
                 .collect(),
-            output: self.output.clone(),
+            outputs: self.outputs.clone(),
         };
-        sha256d::Hash::from_byte_array(cloned_tx.compute_txid().to_byte_array())
+        Ntxid::from_byte_array(normalized.compute_txid().to_byte_array())
     }
 
     /// Computes the [`Txid`].
@@ -183,16 +184,27 @@ impl Transaction {
         Wtxid::from_byte_array(hash.to_byte_array())
     }
 
-    /// Returns whether or not to serialize transaction as specified in BIP-144.
+    /// Returns whether or not to serialize transaction as specified in BIP-0144.
     // This is duplicated in `bitcoin`, if you change it please do so in both places.
     #[inline]
     fn uses_segwit_serialization(&self) -> bool {
-        if self.input.iter().any(|input| !input.witness.is_empty()) {
+        if self.inputs.iter().any(|input| !input.witness.is_empty()) {
             return true;
         }
-        // To avoid serialization ambiguity, no inputs means we use BIP141 serialization (see
+        // To avoid serialization ambiguity, no inputs means we use BIP-0141 serialization (see
         // `Transaction` docs for full explanation).
-        self.input.is_empty()
+        self.inputs.is_empty()
+    }
+
+    /// Checks if this is a coinbase transaction.
+    ///
+    /// The first transaction in the block distributes the mining reward and is called the coinbase
+    /// transaction. It is impossible to check if the transaction is first in the block, so this
+    /// function checks the structure of the transaction instead - the previous output must be
+    /// all-zeros (creates satoshis "out of thin air").
+    #[doc(alias = "is_coin_base")] // method previously had this name
+    pub fn is_coinbase(&self) -> bool {
+        self.inputs.len() == 1 && self.inputs[0].previous_output == OutPoint::COINBASE_PREVOUT
     }
 }
 
@@ -208,40 +220,46 @@ impl cmp::Ord for Transaction {
         self.version
             .cmp(&other.version)
             .then(self.lock_time.to_consensus_u32().cmp(&other.lock_time.to_consensus_u32()))
-            .then(self.input.cmp(&other.input))
-            .then(self.output.cmp(&other.output))
+            .then(self.inputs.cmp(&other.inputs))
+            .then(self.outputs.cmp(&other.outputs))
     }
 }
 
 #[cfg(feature = "alloc")]
 impl From<Transaction> for Txid {
     #[inline]
-    fn from(tx: Transaction) -> Txid { tx.compute_txid() }
+    fn from(tx: Transaction) -> Self { tx.compute_txid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Transaction> for Txid {
     #[inline]
-    fn from(tx: &Transaction) -> Txid { tx.compute_txid() }
+    fn from(tx: &Transaction) -> Self { tx.compute_txid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<Transaction> for Wtxid {
     #[inline]
-    fn from(tx: Transaction) -> Wtxid { tx.compute_wtxid() }
+    fn from(tx: Transaction) -> Self { tx.compute_wtxid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Transaction> for Wtxid {
     #[inline]
-    fn from(tx: &Transaction) -> Wtxid { tx.compute_wtxid() }
+    fn from(tx: &Transaction) -> Self { tx.compute_wtxid() }
 }
 
+/// Trait that abstracts over a transaction identifier i.e., `Txid` and `Wtxid`.
+pub(crate) trait TxIdentifier: AsRef<[u8]> {}
+
+impl TxIdentifier for Txid {}
+impl TxIdentifier for Wtxid {}
+
 // Duplicated in `bitcoin`.
-/// The marker MUST be a 1-byte zero value: 0x00. (BIP-141)
+/// The marker MUST be a 1-byte zero value: 0x00. (BIP-0141)
 #[cfg(feature = "alloc")]
 const SEGWIT_MARKER: u8 = 0x00;
-/// The flag MUST be a 1-byte non-zero value. Currently, 0x01 MUST be used. (BIP-141)
+/// The flag MUST be a 1-byte non-zero value. Currently, 0x01 MUST be used. (BIP-0141)
 #[cfg(feature = "alloc")]
 const SEGWIT_FLAG: u8 = 0x01;
 
@@ -254,15 +272,15 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     enc.input(&tx.version.0.to_le_bytes()); // Same as `encode::emit_i32`.
 
     if uses_segwit_serialization {
-        // BIP-141 (SegWit) transaction serialization also includes marker and flag.
+        // BIP-0141 (SegWit) transaction serialization also includes marker and flag.
         enc.input(&[SEGWIT_MARKER]);
         enc.input(&[SEGWIT_FLAG]);
     }
 
     // Encode inputs (excluding witness data) with leading compact size encoded int.
-    let input_len = tx.input.len();
+    let input_len = tx.inputs.len();
     enc.input(compact_size::encode(input_len).as_slice());
-    for input in &tx.input {
+    for input in &tx.inputs {
         // Encode each input same as we do in `Encodable for TxIn`.
         enc.input(input.previous_output.txid.as_byte_array());
         enc.input(&input.previous_output.vout.to_le_bytes());
@@ -275,11 +293,11 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     }
 
     // Encode outputs with leading compact size encoded int.
-    let output_len = tx.output.len();
+    let output_len = tx.outputs.len();
     enc.input(compact_size::encode(output_len).as_slice());
-    for output in &tx.output {
+    for output in &tx.outputs {
         // Encode each output same as we do in `Encodable for TxOut`.
-        enc.input(&output.value.to_sat().to_le_bytes());
+        enc.input(&output.amount.to_sat().to_le_bytes());
 
         let script_pubkey_bytes = output.script_pubkey.as_bytes();
         enc.input(compact_size::encode(script_pubkey_bytes.len()).as_slice());
@@ -287,8 +305,8 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     }
 
     if uses_segwit_serialization {
-        // BIP-141 (SegWit) transaction serialization also includes the witness data.
-        for input in &tx.input {
+        // BIP-0141 (SegWit) transaction serialization also includes the witness data.
+        for input in &tx.inputs {
             // Same as `Encodable for Witness`.
             enc.input(compact_size::encode(input.witness.len()).as_slice());
             for element in &input.witness {
@@ -304,6 +322,399 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     sha256d::Hash::from_engine(enc)
 }
 
+#[cfg(feature = "alloc")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`Transaction`] type.
+    pub struct TransactionEncoder<'e>(
+        Encoder6<
+            VersionEncoder,
+        Option<ArrayEncoder<2>>,
+        Encoder2<CompactSizeEncoder, SliceEncoder<'e, TxIn>>,
+        Encoder2<CompactSizeEncoder, SliceEncoder<'e, TxOut>>,
+        Option<WitnessesEncoder<'e>>,
+        LockTimeEncoder,
+        >
+    );
+}
+
+#[cfg(feature = "alloc")]
+impl Encodable for Transaction {
+    type Encoder<'e>
+        = TransactionEncoder<'e>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let version = self.version.encoder();
+        let inputs = Encoder2::new(
+            CompactSizeEncoder::new(self.inputs.len()),
+            SliceEncoder::without_length_prefix(self.inputs.as_ref()),
+        );
+        let outputs = Encoder2::new(
+            CompactSizeEncoder::new(self.outputs.len()),
+            SliceEncoder::without_length_prefix(self.outputs.as_ref()),
+        );
+        let lock_time = self.lock_time.encoder();
+
+        if self.uses_segwit_serialization() {
+            let segwit = ArrayEncoder::without_length_prefix([0x00, 0x01]);
+            let witnesses = WitnessesEncoder::new(self.inputs.as_slice());
+            TransactionEncoder(Encoder6::new(
+                version,
+                Some(segwit),
+                inputs,
+                outputs,
+                Some(witnesses),
+                lock_time,
+            ))
+        } else {
+            TransactionEncoder(Encoder6::new(version, None, inputs, outputs, None, lock_time))
+        }
+    }
+}
+
+/// The decoder for the [`Transaction`] type.
+#[cfg(feature = "alloc")]
+pub struct TransactionDecoder {
+    state: TransactionDecoderState,
+}
+
+#[cfg(feature = "alloc")]
+impl TransactionDecoder {
+    /// Constructs a new [`TransactionDecoder`].
+    pub const fn new() -> Self {
+        Self { state: TransactionDecoderState::Version(VersionDecoder::new()) }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Default for TransactionDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "alloc")]
+#[allow(clippy::too_many_lines)] // TODO: Can we clean this up?
+impl Decoder for TransactionDecoder {
+    type Output = Transaction;
+    type Error = TransactionDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        use {
+            TransactionDecoderError as E, TransactionDecoderErrorInner as Inner,
+            TransactionDecoderState as State,
+        };
+
+        loop {
+            // Attempt to push to the currently-active decoder and return early on success.
+            match &mut self.state {
+                State::Version(decoder) => {
+                    if decoder.push_bytes(bytes)? {
+                        // Still more bytes required.
+                        return Ok(true);
+                    }
+                }
+                State::Inputs(_, _, decoder) =>
+                    if decoder.push_bytes(bytes)? {
+                        return Ok(true);
+                    },
+                State::SegwitFlag(_) =>
+                    if bytes.is_empty() {
+                        return Ok(true);
+                    },
+                State::Outputs(_, _, _, decoder) =>
+                    if decoder.push_bytes(bytes)? {
+                        return Ok(true);
+                    },
+                State::Witnesses(_, _, _, _, decoder) =>
+                    if decoder.push_bytes(bytes)? {
+                        return Ok(true);
+                    },
+                State::LockTime(_, _, _, decoder) =>
+                    if decoder.push_bytes(bytes)? {
+                        return Ok(true);
+                    },
+                State::Done(..) => return Ok(false),
+                State::Errored => panic!("call to push_bytes() after decoder errored"),
+            }
+
+            // If the above failed, end the current decoder and go to the next state.
+            match mem::replace(&mut self.state, State::Errored) {
+                State::Version(decoder) => {
+                    let version = decoder.end()?;
+                    self.state = State::Inputs(version, Attempt::First, VecDecoder::<TxIn>::new());
+                }
+                State::Inputs(version, attempt, decoder) => {
+                    let inputs = decoder.end()?;
+
+                    if Attempt::First == attempt {
+                        if inputs.is_empty() {
+                            self.state = State::SegwitFlag(version);
+                        } else {
+                            self.state = State::Outputs(
+                                version,
+                                inputs,
+                                IsSegwit::No,
+                                VecDecoder::<TxOut>::new(),
+                            );
+                        }
+                    } else {
+                        self.state = State::Outputs(
+                            version,
+                            inputs,
+                            IsSegwit::Yes,
+                            VecDecoder::<TxOut>::new(),
+                        );
+                    }
+                }
+                State::SegwitFlag(version) => {
+                    let segwit_flag = bytes[0];
+                    *bytes = &bytes[1..];
+
+                    if segwit_flag != 1 {
+                        return Err(E(Inner::UnsupportedSegwitFlag(segwit_flag)));
+                    }
+                    self.state = State::Inputs(version, Attempt::Second, VecDecoder::<TxIn>::new());
+                }
+                State::Outputs(version, inputs, is_segwit, decoder) => {
+                    let outputs = decoder.end()?;
+                    // Handle the zero-input case described in the `Transaction` docs.
+                    if is_segwit == IsSegwit::Yes && !inputs.is_empty() {
+                        self.state = State::Witnesses(
+                            version,
+                            inputs,
+                            outputs,
+                            Iteration(0),
+                            WitnessDecoder::new(),
+                        );
+                    } else {
+                        self.state =
+                            State::LockTime(version, inputs, outputs, LockTimeDecoder::new());
+                    }
+                }
+                State::Witnesses(version, mut inputs, outputs, iteration, decoder) => {
+                    let iteration = iteration.0;
+
+                    inputs[iteration].witness = decoder.end()?;
+                    if iteration < inputs.len() - 1 {
+                        self.state = State::Witnesses(
+                            version,
+                            inputs,
+                            outputs,
+                            Iteration(iteration + 1),
+                            WitnessDecoder::new(),
+                        );
+                    } else {
+                        if !inputs.is_empty() && inputs.iter().all(|input| input.witness.is_empty())
+                        {
+                            return Err(E(Inner::NoWitnesses));
+                        }
+                        self.state =
+                            State::LockTime(version, inputs, outputs, LockTimeDecoder::new());
+                    }
+                }
+                State::LockTime(version, inputs, outputs, decoder) => {
+                    let lock_time = decoder.end()?;
+                    self.state = State::Done(Transaction { version, lock_time, inputs, outputs });
+                    return Ok(false);
+                }
+                State::Done(..) => return Ok(false),
+                State::Errored => unreachable!("checked above"),
+            }
+        }
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use {
+            TransactionDecoderError as E, TransactionDecoderErrorInner as Inner,
+            TransactionDecoderState as State,
+        };
+
+        match self.state {
+            State::Version(_) => Err(E(Inner::EarlyEnd("version"))),
+            State::Inputs(..) => Err(E(Inner::EarlyEnd("inputs"))),
+            State::SegwitFlag(..) => Err(E(Inner::EarlyEnd("segwit flag"))),
+            State::Outputs(..) => Err(E(Inner::EarlyEnd("outputs"))),
+            State::Witnesses(..) => Err(E(Inner::EarlyEnd("witnesses"))),
+            State::LockTime(..) => Err(E(Inner::EarlyEnd("locktime"))),
+            State::Done(tx) => Ok(tx),
+            State::Errored => panic!("call to end() after decoder errored"),
+        }
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize {
+        use TransactionDecoderState as State;
+
+        match &self.state {
+            State::Version(decoder) => decoder.read_limit(),
+            State::Inputs(_, _, decoder) => decoder.read_limit(),
+            State::SegwitFlag(_) => 1,
+            State::Outputs(_, _, _, decoder) => decoder.read_limit(),
+            State::Witnesses(_, _, _, _, decoder) => decoder.read_limit(),
+            State::LockTime(_, _, _, decoder) => decoder.read_limit(),
+            State::Done(_) => 0,
+            // `read_limit` is not documented to panic or return an error, so we
+            // return a dummy value if the decoder is in an error state.
+            State::Errored => 0,
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Decodable for Transaction {
+    type Decoder = TransactionDecoder;
+    fn decoder() -> Self::Decoder { TransactionDecoder::new() }
+}
+
+/// The state of the transiting decoder.
+#[cfg(feature = "alloc")]
+enum TransactionDecoderState {
+    /// Decoding the transaction version.
+    Version(VersionDecoder),
+    /// Decoding the transaction inputs.
+    Inputs(Version, Attempt, VecDecoder<TxIn>),
+    /// Decoding the segwit flag.
+    SegwitFlag(Version),
+    /// Decoding the transaction outputs.
+    Outputs(Version, Vec<TxIn>, IsSegwit, VecDecoder<TxOut>),
+    /// Decoding the segwit transaction witnesses.
+    Witnesses(Version, Vec<TxIn>, Vec<TxOut>, Iteration, WitnessDecoder),
+    /// Decoding the transaction lock time.
+    LockTime(Version, Vec<TxIn>, Vec<TxOut>, LockTimeDecoder),
+    /// Done decoding the [`Transaction`].
+    Done(Transaction),
+    /// When `end()`ing a sub-decoder, encountered an error which prevented us
+    /// from constructing the next sub-decoder.
+    Errored,
+}
+
+/// Boolean used to track number of times we have attempted to decode the inputs vector.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum Attempt {
+    /// First time reading inputs.
+    First,
+    /// Second time reading inputs.
+    Second,
+}
+
+/// Boolean used to track whether or not this transaction uses segwit encoding.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum IsSegwit {
+    /// Yes so uses segwit encoding.
+    Yes,
+    /// No segwit flag, marker, or witnesses.
+    No,
+}
+
+/// How many times we have state transitioned to encoding a witness (zero-based).
+#[cfg(feature = "alloc")]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+struct Iteration(usize);
+
+/// An error consensus decoding a `Transaction`.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TransactionDecoderError(TransactionDecoderErrorInner);
+
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum TransactionDecoderErrorInner {
+    /// Error while decoding the `version`.
+    Version(VersionDecoderError),
+    /// We only support segwit flag value 0x01.
+    UnsupportedSegwitFlag(u8),
+    /// Error while decoding the `inputs`.
+    Inputs(VecDecoderError<TxInDecoderError>),
+    /// Error while decoding the `outputs`.
+    Outputs(VecDecoderError<TxOutDecoderError>),
+    /// Error while decoding one of the witnesses.
+    Witness(WitnessDecoderError),
+    /// Non-empty Segwit transaction with no witnesses.
+    NoWitnesses,
+    /// Error while decoding the `lock_time`.
+    LockTime(LockTimeDecoderError),
+    /// Attempt to call `end()` before the transaction was complete. Holds
+    /// a description of the current state.
+    EarlyEnd(&'static str),
+}
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for TransactionDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl From<VersionDecoderError> for TransactionDecoderError {
+    fn from(e: VersionDecoderError) -> Self { Self(TransactionDecoderErrorInner::Version(e)) }
+}
+
+#[cfg(feature = "alloc")]
+impl From<VecDecoderError<TxInDecoderError>> for TransactionDecoderError {
+    fn from(e: VecDecoderError<TxInDecoderError>) -> Self {
+        Self(TransactionDecoderErrorInner::Inputs(e))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl From<VecDecoderError<TxOutDecoderError>> for TransactionDecoderError {
+    fn from(e: VecDecoderError<TxOutDecoderError>) -> Self {
+        Self(TransactionDecoderErrorInner::Outputs(e))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl From<WitnessDecoderError> for TransactionDecoderError {
+    fn from(e: WitnessDecoderError) -> Self { Self(TransactionDecoderErrorInner::Witness(e)) }
+}
+
+#[cfg(feature = "alloc")]
+impl From<LockTimeDecoderError> for TransactionDecoderError {
+    fn from(e: LockTimeDecoderError) -> Self { Self(TransactionDecoderErrorInner::LockTime(e)) }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for TransactionDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use TransactionDecoderErrorInner as E;
+
+        match self.0 {
+            E::Version(ref e) => write_err!(f, "transaction decoder error"; e),
+            E::UnsupportedSegwitFlag(v) => {
+                write!(f, "we only support segwit flag value 0x01: {}", v)
+            }
+            E::Inputs(ref e) => write_err!(f, "transaction decoder error"; e),
+            E::Outputs(ref e) => write_err!(f, "transaction decoder error"; e),
+            E::Witness(ref e) => write_err!(f, "transaction decoder error"; e),
+            E::NoWitnesses => write!(f, "non-empty Segwit transaction with no witnesses"),
+            E::LockTime(ref e) => write_err!(f, "transaction decoder error"; e),
+            E::EarlyEnd(s) => write!(f, "early end of transaction (still decoding {})", s),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
+impl std::error::Error for TransactionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TransactionDecoderErrorInner as E;
+
+        match self.0 {
+            E::Version(ref e) => Some(e),
+            E::UnsupportedSegwitFlag(_) => None,
+            E::Inputs(ref e) => Some(e),
+            E::Outputs(ref e) => Some(e),
+            E::Witness(ref e) => Some(e),
+            E::NoWitnesses => None,
+            E::LockTime(ref e) => Some(e),
+            E::EarlyEnd(_) => None,
+        }
+    }
+}
+
 /// Bitcoin transaction input.
 ///
 /// It contains the location of the previous transaction's output,
@@ -314,14 +725,13 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
 ///
 /// * [CTxIn definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L65)
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg(feature = "alloc")]
 pub struct TxIn {
     /// The reference to the previous output that is being used as an input.
     pub previous_output: OutPoint,
     /// The script which pushes values on the stack which will cause
     /// the referenced output's script to be accepted.
-    pub script_sig: ScriptBuf,
+    pub script_sig: ScriptSigBuf,
     /// The sequence number, which suggests to miners which of two
     /// conflicting transactions should be preferred, or 0xFFFFFFFF
     /// to ignore this feature. This is generally never used since
@@ -338,14 +748,162 @@ pub struct TxIn {
 #[cfg(feature = "alloc")]
 impl TxIn {
     /// An empty transaction input with the previous output as for a coinbase transaction.
-    pub const EMPTY_COINBASE: TxIn = TxIn {
+    pub const EMPTY_COINBASE: Self = Self {
         previous_output: OutPoint::COINBASE_PREVOUT,
-        script_sig: ScriptBuf::new(),
+        script_sig: ScriptSigBuf::new(),
         sequence: Sequence::MAX,
         witness: Witness::new(),
     };
 }
 
+#[cfg(feature = "alloc")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`TxIn`] type.
+    pub struct TxInEncoder<'e>(
+        Encoder3<OutPointEncoder<'e>, ScriptEncoder<'e>, SequenceEncoder>
+    );
+}
+
+#[cfg(feature = "alloc")]
+impl Encodable for TxIn {
+    type Encoder<'e>
+        = Encoder3<OutPointEncoder<'e>, ScriptEncoder<'e>, SequenceEncoder>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder3::new(
+            self.previous_output.encoder(),
+            self.script_sig.encoder(),
+            self.sequence.encoder(),
+        )
+    }
+}
+
+/// Encodes the witnesses from a list of inputs.
+#[cfg(feature = "alloc")]
+pub struct WitnessesEncoder<'e> {
+    inputs: &'e [TxIn],
+    /// Encoder for the current witness being encoded.
+    cur_enc: Option<WitnessEncoder<'e>>,
+}
+
+#[cfg(feature = "alloc")]
+impl<'e> WitnessesEncoder<'e> {
+    /// Constructs a new encoder for all witnesses in a list of transaction inputs.
+    pub fn new(inputs: &'e [TxIn]) -> Self {
+        Self { inputs, cur_enc: inputs.first().map(|input| input.witness.encoder()) }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Encoder for WitnessesEncoder<'_> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] {
+        self.cur_enc.as_ref().map(WitnessEncoder::current_chunk).unwrap_or_default()
+    }
+
+    #[inline]
+    fn advance(&mut self) -> bool {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return false;
+        };
+
+        loop {
+            // On subsequent calls, attempt to advance the current encoder and return
+            // success if this succeeds.
+            if cur.advance() {
+                return true;
+            }
+            // self.inputs guaranteed to be non-empty if cur_enc is non-None.
+            self.inputs = &self.inputs[1..];
+
+            // If advancing the current encoder failed, attempt to move to the next encoder.
+            if let Some(input) = self.inputs.first() {
+                *cur = input.witness.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return true;
+                }
+            } else {
+                self.cur_enc = None; // shortcut the next call to advance()
+                return false;
+            }
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+type TxInInnerDecoder = Decoder3<OutPointDecoder, ScriptSigBufDecoder, SequenceDecoder>;
+
+/// The decoder for the [`TxIn`] type.
+#[cfg(feature = "alloc")]
+pub struct TxInDecoder(TxInInnerDecoder);
+
+#[cfg(feature = "alloc")]
+impl Decoder for TxInDecoder {
+    type Output = TxIn;
+    type Error = TxInDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(TxInDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (previous_output, script_sig, sequence) = self.0.end().map_err(TxInDecoderError)?;
+        Ok(TxIn { previous_output, script_sig, sequence, witness: Witness::default() })
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "alloc")]
+impl Decodable for TxIn {
+    type Decoder = TxInDecoder;
+    fn decoder() -> Self::Decoder {
+        TxInDecoder(Decoder3::new(
+            OutPointDecoder::new(),
+            ScriptSigBufDecoder::new(),
+            SequenceDecoder::new(),
+        ))
+    }
+}
+
+/// An error consensus decoding a `TxIn`.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TxInDecoderError(<TxInInnerDecoder as Decoder>::Error);
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for TxInDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for TxInDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self.0 {
+            encoding::Decoder3Error::First(ref e) => write_err!(f, "txin decoder error"; e),
+            encoding::Decoder3Error::Second(ref e) => write_err!(f, "txin decoder error"; e),
+            encoding::Decoder3Error::Third(ref e) => write_err!(f, "txin decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg(feature = "std")]
+impl std::error::Error for TxInDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.0 {
+            encoding::Decoder3Error::First(ref e) => Some(e),
+            encoding::Decoder3Error::Second(ref e) => Some(e),
+            encoding::Decoder3Error::Third(ref e) => Some(e),
+        }
+    }
+}
+
 /// Bitcoin transaction output.
 ///
 /// Defines new coins to be created as a result of the transaction,
@@ -358,14 +916,95 @@ impl TxIn {
 ///
 /// * [CTxOut definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L148)
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg(feature = "alloc")]
 pub struct TxOut {
-    /// The value of the output, in satoshis.
-    #[cfg_attr(feature = "serde", serde(with = "crate::amount::serde::as_sat"))]
-    pub value: Amount,
+    /// The value of the output.
+    pub amount: Amount,
     /// The script which must be satisfied for the output to be spent.
-    pub script_pubkey: ScriptBuf,
+    pub script_pubkey: ScriptPubKeyBuf,
+}
+
+#[cfg(feature = "alloc")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`TxOut`] type.
+    pub struct TxOutEncoder<'e>(Encoder2<AmountEncoder, ScriptEncoder<'e>>);
+}
+
+#[cfg(feature = "alloc")]
+impl Encodable for TxOut {
+    type Encoder<'e>
+        = Encoder2<AmountEncoder, ScriptEncoder<'e>>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder2::new(self.amount.encoder(), self.script_pubkey.encoder())
+    }
+}
+
+#[cfg(feature = "alloc")]
+type TxOutInnerDecoder = Decoder2<AmountDecoder, ScriptPubKeyBufDecoder>;
+
+/// The decoder for the [`TxOut`] type.
+#[cfg(feature = "alloc")]
+pub struct TxOutDecoder(TxOutInnerDecoder);
+
+#[cfg(feature = "alloc")]
+impl Decoder for TxOutDecoder {
+    type Output = TxOut;
+    type Error = TxOutDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(TxOutDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (amount, script_pubkey) = self.0.end().map_err(TxOutDecoderError)?;
+        Ok(TxOut { amount, script_pubkey })
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "alloc")]
+impl Decodable for TxOut {
+    type Decoder = TxOutDecoder;
+    fn decoder() -> Self::Decoder {
+        TxOutDecoder(Decoder2::new(AmountDecoder::new(), ScriptPubKeyBufDecoder::new()))
+    }
+}
+
+/// An error consensus decoding a `TxOut`.
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TxOutDecoderError(<TxOutInnerDecoder as Decoder>::Error);
+
+#[cfg(feature = "alloc")]
+impl From<Infallible> for TxOutDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "alloc")]
+impl fmt::Display for TxOutDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self.0 {
+            encoding::Decoder2Error::First(ref e) => write_err!(f, "txout decoder error"; e),
+            encoding::Decoder2Error::Second(ref e) => write_err!(f, "txout decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TxOutDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.0 {
+            encoding::Decoder2Error::First(ref e) => Some(e),
+            encoding::Decoder2Error::Second(ref e) => Some(e),
+        }
+    }
 }
 
 /// A reference to a transaction output.
@@ -380,8 +1019,6 @@ pub struct OutPoint {
     /// The index of the referenced output in its transaction's vout.
     pub vout: u32,
 }
-#[cfg(feature = "serde")]
-internals::serde_struct_human_string_impl!(OutPoint, "an OutPoint", txid, vout);
 
 impl OutPoint {
     /// The number of bytes that an outpoint contributes to the size of a transaction.
@@ -394,6 +1031,25 @@ impl OutPoint {
     pub const COINBASE_PREVOUT: Self = Self { txid: Txid::COINBASE_PREVOUT, vout: u32::MAX };
 }
 
+encoding::encoder_newtype! {
+    /// The encoder for the [`OutPoint`] type.
+    pub struct OutPointEncoder<'e>(Encoder2<BytesEncoder<'e>, ArrayEncoder<4>>);
+}
+
+impl Encodable for OutPoint {
+    type Encoder<'e>
+        = OutPointEncoder<'e>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        OutPointEncoder(Encoder2::new(
+            BytesEncoder::without_length_prefix(self.txid.as_byte_array()),
+            ArrayEncoder::without_length_prefix(self.vout.to_le_bytes()),
+        ))
+    }
+}
+
 #[cfg(feature = "hex")]
 impl fmt::Display for OutPoint {
     #[inline]
@@ -420,7 +1076,7 @@ impl core::str::FromStr for OutPoint {
         if colon == 0 || colon == s.len() - 1 {
             return Err(ParseOutPointError::Format);
         }
-        Ok(OutPoint {
+        Ok(Self {
             txid: s[..colon].parse().map_err(ParseOutPointError::Txid)?,
             vout: parse_vout(&s[colon + 1..])?,
         })
@@ -439,7 +1095,178 @@ fn parse_vout(s: &str) -> Result<u32, ParseOutPointError> {
             return Err(ParseOutPointError::VoutNotCanonical);
         }
     }
-    parse::int_from_str(s).map_err(ParseOutPointError::Vout)
+    parse_int::int_from_str(s).map_err(ParseOutPointError::Vout)
+}
+
+/// The decoder for the [`OutPoint`] type.
+// 32 for the txid + 4 for the vout
+pub struct OutPointDecoder(encoding::ArrayDecoder<36>);
+
+impl OutPointDecoder {
+    /// Constructs a new [`OutPoint`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for OutPointDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for OutPointDecoder {
+    type Output = OutPoint;
+    type Error = OutPointDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(OutPointDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let encoded = self.0.end().map_err(OutPointDecoderError)?;
+        let (txid_buf, vout_buf) = encoded.split_array::<32, 4>();
+
+        let txid = Txid::from_byte_array(*txid_buf);
+        let vout = u32::from_le_bytes(*vout_buf);
+
+        Ok(OutPoint { txid, vout })
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for OutPoint {
+    type Decoder = OutPointDecoder;
+    fn decoder() -> Self::Decoder { OutPointDecoder::default() }
+}
+
+/// Error while decoding an `OutPoint`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OutPointDecoderError(UnexpectedEofError);
+
+impl core::fmt::Display for OutPointDecoderError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write_err!(f, "out point decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for OutPointDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for OutPoint {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        if serializer.is_human_readable() {
+            serializer.collect_str(&self)
+        } else {
+            use crate::serde::ser::SerializeStruct as _;
+
+            let mut state = serializer.serialize_struct("OutPoint", 2)?;
+            // serializing as an array was found in the past to break for some serializers so we use
+            // a slice instead. This causes 8 bytes to be prepended for the length (even though this
+            // is a bit silly because know the length).
+            state.serialize_field("txid", self.txid.as_byte_array().as_slice())?;
+            state.serialize_field("vout", &self.vout.to_le_bytes())?;
+            state.end()
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for OutPoint {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            struct StringVisitor;
+
+            impl de::Visitor<'_> for StringVisitor {
+                type Value = OutPoint;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("a string in format 'txid:vout'")
+                }
+
+                fn visit_str<E>(self, value: &str) -> Result<OutPoint, E>
+                where
+                    E: de::Error,
+                {
+                    value.parse::<OutPoint>().map_err(de::Error::custom)
+                }
+            }
+
+            deserializer.deserialize_str(StringVisitor)
+        } else {
+            #[derive(Deserialize)]
+            #[serde(field_identifier, rename_all = "lowercase")]
+            enum Field {
+                Txid,
+                Vout,
+            }
+
+            struct OutPointVisitor;
+
+            impl<'de> de::Visitor<'de> for OutPointVisitor {
+                type Value = OutPoint;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("OutPoint struct with fields")
+                }
+
+                fn visit_seq<V>(self, mut seq: V) -> Result<OutPoint, V::Error>
+                where
+                    V: de::SeqAccess<'de>,
+                {
+                    let txid =
+                        seq.next_element()?.ok_or_else(|| de::Error::invalid_length(0, &self))?;
+                    let vout =
+                        seq.next_element()?.ok_or_else(|| de::Error::invalid_length(1, &self))?;
+                    Ok(OutPoint { txid, vout })
+                }
+
+                fn visit_map<V>(self, mut map: V) -> Result<OutPoint, V::Error>
+                where
+                    V: de::MapAccess<'de>,
+                {
+                    let mut txid = None;
+                    let mut vout = None;
+
+                    while let Some(key) = map.next_key()? {
+                        match key {
+                            Field::Txid => {
+                                if txid.is_some() {
+                                    return Err(de::Error::duplicate_field("txid"));
+                                }
+                                let bytes: [u8; 32] = map.next_value()?;
+                                txid = Some(Txid::from_byte_array(bytes));
+                            }
+                            Field::Vout => {
+                                if vout.is_some() {
+                                    return Err(de::Error::duplicate_field("vout"));
+                                }
+                                let bytes: [u8; 4] = map.next_value()?;
+                                vout = Some(u32::from_le_bytes(bytes));
+                            }
+                        }
+                    }
+
+                    let txid = txid.ok_or_else(|| de::Error::missing_field("txid"))?;
+                    let vout = vout.ok_or_else(|| de::Error::missing_field("vout"))?;
+
+                    Ok(OutPoint { txid, vout })
+                }
+            }
+
+            const FIELDS: &[&str] = &["txid", "vout"];
+            deserializer.deserialize_struct("OutPoint", FIELDS, OutPointVisitor)
+        }
+    }
 }
 
 /// An error in parsing an [`OutPoint`].
@@ -449,9 +1276,9 @@ fn parse_vout(s: &str) -> Result<u32, ParseOutPointError> {
 #[cfg(feature = "hex")]
 pub enum ParseOutPointError {
     /// Error in TXID part.
-    Txid(hex::HexToArrayError),
+    Txid(hex::DecodeFixedLengthBytesError),
     /// Error in vout part.
-    Vout(parse::ParseIntError),
+    Vout(parse_int::ParseIntError),
     /// Error in general format.
     Format,
     /// Size exceeds max.
@@ -471,14 +1298,12 @@ impl From<Infallible> for ParseOutPointError {
 #[cfg(feature = "hex")]
 impl fmt::Display for ParseOutPointError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseOutPointError as E;
-
         match *self {
-            E::Txid(ref e) => write_err!(f, "error parsing TXID"; e),
-            E::Vout(ref e) => write_err!(f, "error parsing vout"; e),
-            E::Format => write!(f, "OutPoint not in <txid>:<vout> format"),
-            E::TooLong => write!(f, "vout should be at most 10 digits"),
-            E::VoutNotCanonical => write!(f, "no leading zeroes or + allowed in vout part"),
+            Self::Txid(ref e) => write_err!(f, "error parsing TXID"; e),
+            Self::Vout(ref e) => write_err!(f, "error parsing vout"; e),
+            Self::Format => write!(f, "OutPoint not in <txid>:<vout> format"),
+            Self::TooLong => write!(f, "vout should be at most 10 digits"),
+            Self::VoutNotCanonical => write!(f, "no leading zeroes or + allowed in vout part"),
         }
     }
 }
@@ -487,84 +1312,43 @@ impl fmt::Display for ParseOutPointError {
 #[cfg(feature = "hex")]
 impl std::error::Error for ParseOutPointError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseOutPointError as E;
-
         match self {
-            E::Txid(e) => Some(e),
-            E::Vout(e) => Some(e),
-            E::Format | E::TooLong | E::VoutNotCanonical => None,
+            Self::Txid(e) => Some(e),
+            Self::Vout(e) => Some(e),
+            Self::Format | Self::TooLong | Self::VoutNotCanonical => None,
         }
     }
 }
 
-hashes::hash_newtype! {
-    /// A bitcoin transaction hash/transaction ID.
-    ///
-    /// For compatibility with the existing Bitcoin infrastructure and historical and current
-    /// versions of the Bitcoin Core software itself, this and other [`sha256d::Hash`] types, are
-    /// serialized in reverse byte order when converted to a hex string via [`std::fmt::Display`]
-    /// trait operations.
-    ///
-    /// See [`hashes::Hash::DISPLAY_BACKWARD`] for more details.
-    pub struct Txid(sha256d::Hash);
-
-    /// A bitcoin witness transaction ID.
-    pub struct Wtxid(sha256d::Hash);
-}
-
-#[cfg(feature = "hex")]
-hashes::impl_hex_for_newtype!(Txid, Wtxid);
-#[cfg(not(feature = "hex"))]
-hashes::impl_debug_only_for_newtype!(Txid, Wtxid);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(Txid, Wtxid);
-
-impl Txid {
-    /// The `Txid` used in a coinbase prevout.
-    ///
-    /// This is used as the "txid" of the dummy input of a coinbase transaction. This is not a real
-    /// TXID and should not be used in any other contexts. See [`OutPoint::COINBASE_PREVOUT`].
-    pub const COINBASE_PREVOUT: Self = Self::from_byte_array([0; 32]);
-}
-
-impl Wtxid {
-    /// The `Wtxid` of a coinbase transaction.
-    ///
-    /// This is used as the wTXID for the coinbase transaction when constructing blocks (in the
-    /// witness commitment tree) since the coinbase transaction contains a commitment to all
-    /// transactions' wTXIDs but naturally cannot commit to its own.
-    pub const COINBASE: Self = Self::from_byte_array([0; 32]);
-}
-
 /// The transaction version.
 ///
-/// Currently, as specified by [BIP-68] and [BIP-431], version 1, 2, and 3 are considered standard.
+/// Currently, as specified by [BIP-0068] and [BIP-0431], version 1, 2, and 3 are considered standard.
 ///
 /// Standardness of the inner `u32` is not an invariant because you are free to create transactions
 /// of any version, transactions with non-standard version numbers will not be relayed by the
 /// Bitcoin network.
 ///
-/// [BIP-68]: https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki
-/// [BIP-431]: https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki
+/// [BIP-0068]: https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki
+/// [BIP-0431]: https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki
 #[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Version(u32);
 
 impl Version {
-    /// The original Bitcoin transaction version (pre-BIP-68).
+    /// The original Bitcoin transaction version (pre-BIP-0068).
     pub const ONE: Self = Self(1);
 
-    /// The second Bitcoin transaction version (post-BIP-68).
+    /// The second Bitcoin transaction version (post-BIP-0068).
     pub const TWO: Self = Self(2);
 
-    /// The third Bitcoin transaction version (post-BIP-431).
+    /// The third Bitcoin transaction version (post-BIP-0431).
     pub const THREE: Self = Self(3);
 
     /// Constructs a potentially non-standard transaction version.
     ///
     /// This can accept both standard and non-standard versions.
     #[inline]
-    pub const fn maybe_non_standard(version: u32) -> Version { Self(version) }
+    pub const fn maybe_non_standard(version: u32) -> Self { Self(version) }
 
     /// Returns the inner `u32` value of this `Version`.
     #[inline]
@@ -578,7 +1362,7 @@ impl Version {
     /// versions 1, 2, and 3 are considered standard.
     #[inline]
     pub const fn is_standard(self) -> bool {
-        self.0 == Version::ONE.0 || self.0 == Version::TWO.0 || self.0 == Version::THREE.0
+        self.0 == Self::ONE.0 || self.0 == Self::TWO.0 || self.0 == Self::THREE.0
     }
 }
 
@@ -592,15 +1376,83 @@ impl From<Version> for u32 {
     fn from(version: Version) -> Self { version.0 }
 }
 
+encoding::encoder_newtype! {
+    /// The encoder for the [`Version`] type.
+    pub struct VersionEncoder(encoding::ArrayEncoder<4>);
+}
+
+impl encoding::Encodable for Version {
+    type Encoder<'e> = VersionEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        VersionEncoder(encoding::ArrayEncoder::without_length_prefix(self.to_u32().to_le_bytes()))
+    }
+}
+
+/// The decoder for the [`Version`] type.
+pub struct VersionDecoder(encoding::ArrayDecoder<4>);
+
+impl VersionDecoder {
+    /// Constructs a new [`Version`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+impl Default for VersionDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for VersionDecoder {
+    type Output = Version;
+    type Error = VersionDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(VersionDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let bytes = self.0.end().map_err(VersionDecoderError)?;
+        let n = u32::from_le_bytes(bytes);
+        Ok(Version::maybe_non_standard(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+impl encoding::Decodable for Version {
+    type Decoder = VersionDecoder;
+    fn decoder() -> Self::Decoder { VersionDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `Version`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VersionDecoderError(encoding::UnexpectedEofError);
+
+impl From<Infallible> for VersionDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl fmt::Display for VersionDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "version decoder error"; self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for VersionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
 #[cfg(feature = "arbitrary")]
 #[cfg(feature = "alloc")]
 impl<'a> Arbitrary<'a> for Transaction {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Transaction {
+        Ok(Self {
             version: Version::arbitrary(u)?,
             lock_time: absolute::LockTime::arbitrary(u)?,
-            input: Vec::<TxIn>::arbitrary(u)?,
-            output: Vec::<TxOut>::arbitrary(u)?,
+            inputs: Vec::<TxIn>::arbitrary(u)?,
+            outputs: Vec::<TxOut>::arbitrary(u)?,
         })
     }
 }
@@ -609,9 +1461,9 @@ impl<'a> Arbitrary<'a> for Transaction {
 #[cfg(feature = "alloc")]
 impl<'a> Arbitrary<'a> for TxIn {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(TxIn {
+        Ok(Self {
             previous_output: OutPoint::arbitrary(u)?,
-            script_sig: ScriptBuf::arbitrary(u)?,
+            script_sig: ScriptSigBuf::arbitrary(u)?,
             sequence: Sequence::arbitrary(u)?,
             witness: Witness::arbitrary(u)?,
         })
@@ -622,14 +1474,14 @@ impl<'a> Arbitrary<'a> for TxIn {
 #[cfg(feature = "alloc")]
 impl<'a> Arbitrary<'a> for TxOut {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(TxOut { value: Amount::arbitrary(u)?, script_pubkey: ScriptBuf::arbitrary(u)? })
+        Ok(Self { amount: Amount::arbitrary(u)?, script_pubkey: ScriptPubKeyBuf::arbitrary(u)? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for OutPoint {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(OutPoint { txid: Txid::arbitrary(u)?, vout: u32::arbitrary(u)? })
+        Ok(Self { txid: Txid::arbitrary(u)?, vout: u32::arbitrary(u)? })
     }
 }
 
@@ -639,27 +1491,49 @@ impl<'a> Arbitrary<'a> for Version {
         // Equally weight the case of normal version numbers
         let choice = u.int_in_range(0..=3)?;
         match choice {
-            0 => Ok(Version::ONE),
-            1 => Ok(Version::TWO),
-            2 => Ok(Version::THREE),
-            _ => Ok(Version(u.arbitrary()?)),
+            0 => Ok(Self::ONE),
+            1 => Ok(Self::TWO),
+            2 => Ok(Self::THREE),
+            _ => Ok(Self(u.arbitrary()?)),
         }
     }
 }
 
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for Txid {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let arbitrary_bytes = u.arbitrary()?;
-        let t = sha256d::Hash::from_byte_array(arbitrary_bytes);
-        Ok(Txid(t))
-    }
-}
-
 #[cfg(feature = "alloc")]
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "hex")]
+    use alloc::string::ToString;
+    use alloc::{format, vec};
+
+    use encoding::Encoder as _;
+    #[cfg(feature = "hex")]
+    use hex_lit::hex;
+
     use super::*;
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    use crate::absolute::LockTime;
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn transaction_encode_decode_roundtrip() {
+        let tx = Transaction {
+            version: Version::TWO,
+            lock_time: absolute::LockTime::ZERO,
+            inputs: vec![segwit_tx_in(), segwit_tx_in()],
+            outputs: vec![tx_out(), tx_out()],
+        };
+
+        let encoded = encoding::encode_to_vec(&tx);
+
+        let mut decoder = Transaction::decoder();
+        let mut slice = encoded.as_slice();
+        decoder.push_bytes(&mut slice).unwrap();
+        let decoded = decoder.end().unwrap();
+
+        assert_eq!(tx, decoded);
+    }
 
     #[test]
     fn sanity_check() {
@@ -680,33 +1554,33 @@ mod tests {
                 txid: Txid::from_byte_array([0xAA; 32]), // Arbitrary invalid dummy value.
                 vout: 0,
             },
-            script_sig: ScriptBuf::new(),
+            script_sig: ScriptSigBuf::new(),
             sequence: Sequence::MAX,
             witness: Witness::new(),
         };
 
         let txout = TxOut {
-            value: Amount::from_sat(123_456_789).unwrap(),
-            script_pubkey: ScriptBuf::new(),
+            amount: Amount::from_sat(123_456_789).unwrap(),
+            script_pubkey: ScriptPubKeyBuf::new(),
         };
 
         let tx_orig = Transaction {
             version: Version::ONE,
             lock_time: absolute::LockTime::from_consensus(1_738_968_231), // The time this was written
-            input: vec![txin.clone()],
-            output: vec![txout.clone()],
+            inputs: vec![txin],
+            outputs: vec![txout],
         };
 
         // Test changing the transaction
         let mut tx = tx_orig.clone();
-        tx.inputs_mut()[0].previous_output.txid = Txid::from_byte_array([0xFF; 32]);
-        tx.outputs_mut()[0].value = Amount::from_sat(987_654_321).unwrap();
-        assert_eq!(tx.inputs()[0].previous_output.txid.to_byte_array(), [0xFF; 32]);
-        assert_eq!(tx.outputs()[0].value.to_sat(), 987_654_321);
+        tx.inputs[0].previous_output.txid = Txid::from_byte_array([0xFF; 32]);
+        tx.outputs[0].amount = Amount::from_sat(987_654_321).unwrap();
+        assert_eq!(tx.inputs[0].previous_output.txid.to_byte_array(), [0xFF; 32]);
+        assert_eq!(tx.outputs[0].amount.to_sat(), 987_654_321);
 
         // Test uses_segwit_serialization
         assert!(!tx.uses_segwit_serialization());
-        tx.input[0].witness.push(vec![0xAB, 0xCD, 0xEF]);
+        tx.inputs[0].witness.push(vec![0xAB, 0xCD, 0xEF]);
         assert!(tx.uses_segwit_serialization());
 
         // Test partial ord
@@ -733,9 +1607,20 @@ mod tests {
         // Check the number of bytes OutPoint contributes to the transaction is equal to SIZE
         let outpoint_size = outpoint.txid.as_byte_array().len() + outpoint.vout.to_le_bytes().len();
         assert_eq!(outpoint_size, OutPoint::SIZE);
+    }
 
-        // Check TooLong error
-        outpoint_str.push_str("0000000000");
+    #[test]
+    #[cfg(feature = "hex")]
+    fn outpoint_from_str_too_long() {
+        // Check edge case: length exactly 75
+        let mut outpoint_str = "0".repeat(64);
+        outpoint_str.push_str(":1234567890");
+        assert_eq!(outpoint_str.len(), 75);
+        assert!(outpoint_str.parse::<OutPoint>().is_ok());
+
+        // Check TooLong error (length 76)
+        outpoint_str.push('0');
+        assert_eq!(outpoint_str.len(), 76);
         let outpoint: Result<OutPoint, ParseOutPointError> = outpoint_str.parse();
         assert_eq!(outpoint, Err(ParseOutPointError::TooLong));
     }
@@ -763,4 +1648,548 @@ mod tests {
         let version = Version(123);
         assert_eq!(format!("{}", version), "123");
     }
+
+    // Creates an arbitrary dummy outpoint.
+    #[cfg(any(feature = "hex", feature = "serde"))]
+    fn tc_out_point() -> OutPoint {
+        let s = "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20:1";
+        s.parse::<OutPoint>().unwrap()
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn out_point_serde_deserialize_human_readable() {
+        // `sered` serialization is the same as `Display` but includes quotes.
+        let ser = "\"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20:1\"";
+        let got = serde_json::from_str::<OutPoint>(ser).unwrap();
+        let want = tc_out_point();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn out_point_serde_deserialize_non_human_readable() {
+        #[rustfmt::skip]
+        let bytes = [
+            // Length, prepended by the `serde` infrastructure because we use
+            // slice serialization instead of array even though we know the length.
+            32, 0, 0, 0, 0, 0, 0, 0,
+            // The txid bytes
+            32, 31, 30, 29, 28, 27, 26, 25,
+            24, 23, 22, 21, 20, 19, 18, 17,
+            16, 15, 14, 13, 12, 11, 10, 9,
+            8, 7, 6, 5, 4, 3, 2, 1,
+            // The vout
+            1, 0, 0, 0
+        ];
+
+        let got = bincode::deserialize::<OutPoint>(&bytes).unwrap();
+        let want = tc_out_point();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn out_point_serde_human_readable_rountrips() {
+        let out_point = tc_out_point();
+
+        let ser = serde_json::to_string(&out_point).unwrap();
+        let got = serde_json::from_str::<OutPoint>(&ser).unwrap();
+
+        assert_eq!(got, out_point);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn out_point_serde_non_human_readable_rountrips() {
+        let out_point = tc_out_point();
+
+        let ser = bincode::serialize(&out_point).unwrap();
+        let got = bincode::deserialize::<OutPoint>(&ser).unwrap();
+
+        assert_eq!(got, out_point);
+    }
+
+    #[cfg(feature = "alloc")]
+    fn tx_out() -> TxOut { TxOut { amount: Amount::ONE_SAT, script_pubkey: tc_script_pubkey() } }
+
+    #[cfg(any(feature = "hex", feature = "serde"))]
+    fn segwit_tx_in() -> TxIn {
+        let bytes = [1u8, 2, 3];
+        let data = [&bytes[..]];
+        let witness = Witness::from_iter(data);
+
+        TxIn {
+            previous_output: tc_out_point(),
+            script_sig: tc_script_sig(),
+            sequence: Sequence::MAX,
+            witness,
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    fn tc_script_pubkey() -> ScriptPubKeyBuf {
+        let script_bytes = vec![1, 2, 3];
+        ScriptPubKeyBuf::from_bytes(script_bytes)
+    }
+
+    #[cfg(any(feature = "hex", feature = "serde"))]
+    fn tc_script_sig() -> ScriptSigBuf {
+        let script_bytes = vec![1, 2, 3];
+        ScriptSigBuf::from_bytes(script_bytes)
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn encode_out_point() {
+        let out_point = tc_out_point();
+        let mut encoder = out_point.encoder();
+
+        // The txid
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12,
+                11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+            ][..]
+        );
+        assert!(encoder.advance());
+
+        // The vout
+        assert_eq!(encoder.current_chunk(), &[1u8, 0, 0, 0][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn encode_tx_out() {
+        let out = tx_out();
+        let mut encoder = out.encoder();
+
+        // The amount.
+        assert_eq!(encoder.current_chunk(), &[1, 0, 0, 0, 0, 0, 0, 0][..]);
+        assert!(encoder.advance());
+
+        // The script pubkey length prefix.
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+
+        // The script pubkey data.
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn encode_tx_in() {
+        let txin = segwit_tx_in();
+        let mut encoder = txin.encoder();
+
+        // The outpoint (same as tested above).
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12,
+                11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+            ][..]
+        );
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+
+        // The script sig
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+
+        // The sequence
+        assert_eq!(encoder.current_chunk(), &[0xffu8, 0xff, 0xff, 0xff][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn encode_segwit_transaction() {
+        let tx = Transaction {
+            version: Version::TWO,
+            lock_time: LockTime::ZERO,
+            inputs: vec![segwit_tx_in()],
+            outputs: vec![tx_out()],
+        };
+
+        let mut encoder = tx.encoder();
+
+        // The version
+        assert_eq!(encoder.current_chunk(), &[2u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+
+        // The segwit marker and flag
+        assert_eq!(encoder.current_chunk(), &[0u8, 1][..]);
+        assert!(encoder.advance());
+
+        // The input (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12,
+                11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+            ][..]
+        );
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xffu8, 0xff, 0xff, 0xff][..]);
+        assert!(encoder.advance());
+
+        // The output (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1, 0, 0, 0, 0, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+
+        // The witness
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8, 1, 2, 3][..]);
+        assert!(encoder.advance());
+
+        // The lock time.
+        assert_eq!(encoder.current_chunk(), &[0, 0, 0, 0][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn encode_non_segwit_transaction() {
+        let mut tx_in = segwit_tx_in();
+        tx_in.witness = Witness::default();
+
+        let tx = Transaction {
+            version: Version::TWO,
+            lock_time: LockTime::ZERO,
+            inputs: vec![tx_in],
+            outputs: vec![tx_out()],
+        };
+
+        let mut encoder = tx.encoder();
+
+        // The version
+        assert_eq!(encoder.current_chunk(), &[2u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+
+        // Advance past the optional segwit bytes encoder.
+        assert!(encoder.advance());
+
+        // The input (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12,
+                11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+            ][..]
+        );
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xffu8, 0xff, 0xff, 0xff][..]);
+        assert!(encoder.advance());
+
+        // The output (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1, 0, 0, 0, 0, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+
+        // Advance past the optional witnesses encoder.
+        assert!(encoder.advance());
+
+        // The lock time.
+        assert_eq!(encoder.current_chunk(), &[0, 0, 0, 0][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    // FIXME: Move all these encoding tests to a single file in `primitives/tests/`.
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
+    fn encode_block() {
+        use crate::{
+            Block, BlockHash, BlockHeader, BlockTime, BlockVersion, CompactTarget, TxMerkleNode,
+        };
+
+        let seconds: u32 = 1_653_195_600; // Arbitrary timestamp: May 22nd, 5am UTC.
+
+        let header = BlockHeader {
+            version: BlockVersion::TWO,
+            prev_blockhash: BlockHash::from_byte_array([0xab; 32]),
+            merkle_root: TxMerkleNode::from_byte_array([0xcd; 32]),
+            time: BlockTime::from(seconds),
+            bits: CompactTarget::from_consensus(0xbeef),
+            nonce: 0xcafe,
+        };
+
+        let tx = Transaction {
+            version: Version::TWO,
+            lock_time: LockTime::ZERO,
+            inputs: vec![segwit_tx_in()],
+            outputs: vec![tx_out()],
+        };
+
+        let block = Block::new_unchecked(header, vec![tx]);
+        let mut encoder = block.encoder();
+
+        // The block header, 6 encoders, 1 chunk per encoder.
+
+        // The block version.
+        assert_eq!(encoder.current_chunk(), &[2u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        // The previous block's blockhash.
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
+                171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171
+            ][..]
+        );
+        assert!(encoder.advance());
+        // The merkle root hash.
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
+                205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205
+            ][..]
+        );
+        assert!(encoder.advance());
+        // The block time.
+        assert_eq!(encoder.current_chunk(), &[80, 195, 137, 98][..]);
+        assert!(encoder.advance());
+        // The target (bits).
+        assert_eq!(encoder.current_chunk(), &[239, 190, 0, 0][..]);
+        assert!(encoder.advance());
+        // The nonce.
+        assert_eq!(encoder.current_chunk(), &[254, 202, 0, 0][..]);
+        assert!(encoder.advance());
+
+        // The transaction list length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+
+        // The transaction (same as tested above).
+
+        // The version
+        assert_eq!(encoder.current_chunk(), &[2u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        // The segwit marker and flag
+        assert_eq!(encoder.current_chunk(), &[0u8, 1][..]);
+        assert!(encoder.advance());
+        // The input (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(
+            encoder.current_chunk(),
+            &[
+                32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12,
+                11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
+            ][..]
+        );
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[0xffu8, 0xff, 0xff, 0xff][..]);
+        assert!(encoder.advance());
+        // The output (same as tested above) but with vec length prefix.
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1, 0, 0, 0, 0, 0, 0, 0][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[1u8, 2, 3][..]);
+        assert!(encoder.advance());
+        // The witness
+        assert_eq!(encoder.current_chunk(), &[1u8][..]);
+        assert!(encoder.advance());
+        assert_eq!(encoder.current_chunk(), &[3u8, 1, 2, 3][..]);
+        assert!(encoder.advance());
+        // The lock time.
+        assert_eq!(encoder.current_chunk(), &[0, 0, 0, 0][..]);
+        assert!(!encoder.advance());
+
+        // Exhausted
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn decode_segwit_transaction() {
+        let tx_bytes = hex!(
+            "02000000000101595895ea20179de87052b4046dfe6fd515860505d6511a9004cf12a1f93cac7c01000000\
+            00ffffffff01deb807000000000017a9140f3444e271620c736808aa7b33e370bd87cb5a078702483045022\
+            100fb60dad8df4af2841adc0346638c16d0b8035f5e3f3753b88db122e70c79f9370220756e6633b17fd271\
+            0e626347d28d60b0a2d6cbb41de51740644b9fb3ba7751040121028fa937ca8cba2197a37c007176ed89410\
+            55d3bcb8627d085e94553e62f057dcc00000000"
+        );
+        let mut decoder = Transaction::decoder();
+        let mut slice = tx_bytes.as_slice();
+        decoder.push_bytes(&mut slice).unwrap();
+        let tx = decoder.end().unwrap();
+
+        // Attempt various truncations
+        for i in [1, 10, 20, 50, 100, tx_bytes.len() / 2, tx_bytes.len()] {
+            let mut decoder = Transaction::decoder();
+            let mut slice = &tx_bytes[..tx_bytes.len() - i];
+            // push_bytes will not fail because the data is not invalid, just truncated
+            decoder.push_bytes(&mut slice).unwrap();
+            // ...but end() will fail because we will be in some incomplete state
+            decoder.end().unwrap_err();
+        }
+
+        // All these tests aren't really needed because if they fail, the hash check at the end
+        // will also fail. But these will show you where the failure is so I'll leave them in.
+        assert_eq!(tx.version, Version::TWO);
+        assert_eq!(tx.inputs.len(), 1);
+        // In particular this one is easy to get backward -- in bitcoin hashes are encoded
+        // as little-endian 256-bit numbers rather than as data strings.
+        assert_eq!(
+            format!("{:x}", tx.inputs[0].previous_output.txid),
+            "7cac3cf9a112cf04901a51d605058615d56ffe6d04b45270e89d1720ea955859".to_string()
+        );
+        assert_eq!(tx.inputs[0].previous_output.vout, 1);
+        assert_eq!(tx.outputs.len(), 1);
+        assert_eq!(tx.lock_time, absolute::LockTime::ZERO);
+
+        assert_eq!(
+            format!("{:x}", tx.compute_txid()),
+            "f5864806e3565c34d1b41e716f72609d00b55ea5eac5b924c9719a842ef42206".to_string()
+        );
+        assert_eq!(
+            format!("{:x}", tx.compute_wtxid()),
+            "80b7d8a82d5d5bf92905b06f2014dd699e03837ca172e3a59d51426ebbe3e7f5".to_string()
+        );
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn decode_nonsegwit_transaction() {
+        let tx_bytes = hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000");
+
+        let mut decoder = Transaction::decoder();
+        let mut slice = tx_bytes.as_slice();
+        decoder.push_bytes(&mut slice).unwrap();
+        let tx = decoder.end().unwrap();
+
+        // All these tests aren't really needed because if they fail, the hash check at the end
+        // will also fail. But these will show you where the failure is so I'll leave them in.
+        assert_eq!(tx.version, Version::ONE);
+        assert_eq!(tx.inputs.len(), 1);
+        // In particular this one is easy to get backward -- in bitcoin hashes are encoded
+        // as little-endian 256-bit numbers rather than as data strings.
+        assert_eq!(
+            format!("{:x}", tx.inputs[0].previous_output.txid),
+            "ce9ea9f6f5e422c6a9dbcddb3b9a14d1c78fab9ab520cb281aa2a74a09575da1".to_string()
+        );
+        assert_eq!(tx.inputs[0].previous_output.vout, 1);
+        assert_eq!(tx.outputs.len(), 1);
+        assert_eq!(tx.lock_time, absolute::LockTime::ZERO);
+
+        assert_eq!(
+            format!("{:x}", tx.compute_txid()),
+            "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string()
+        );
+        assert_eq!(
+            format!("{:x}", tx.compute_wtxid()),
+            "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string()
+        );
+    }
+
+    #[test]
+    #[cfg(all(feature = "alloc", feature = "hex"))]
+    fn decode_segwit_without_witnesses_errors() {
+        // A SegWit-serialized transaction with 1 input but no witnesses for any input.
+        let tx_bytes = hex!(
+            "02000000\
+             0001\
+             01\
+             0000000000000000000000000000000000000000000000000000000000000000\
+             00000000\
+             00\
+             ffffffff\
+             01\
+             0100000000000000\
+             00\
+             00\
+             00000000"
+        );
+
+        let mut slice = tx_bytes.as_slice();
+        let err = Transaction::decoder()
+            .push_bytes(&mut slice)
+            .expect_err("segwit tx with no witnesses should error");
+
+        assert_eq!(err, TransactionDecoderError(TransactionDecoderErrorInner::NoWitnesses));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_zero_inputs() {
+        // Test empty transaction with no inputs or outputs.
+        let block: u32 = 741_521;
+        let original_tx = Transaction {
+            version: Version::ONE,
+            lock_time: absolute::LockTime::from_height(block).expect("valid height"),
+            inputs: vec![],
+            outputs: vec![],
+        };
+
+        let encoded = encoding::encode_to_vec(&original_tx);
+        let decoded_tx = encoding::decode_from_slice(&encoded).unwrap();
+
+        assert_eq!(original_tx, decoded_tx);
+    }
 }
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index 78bb13d8d0..193bbdc2bb 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -4,18 +4,27 @@
 //!
 //! This module contains the [`Witness`] struct and related methods to operate on it
 
+use core::convert::Infallible;
 use core::fmt;
 use core::ops::Index;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+#[cfg(doc)]
+use encoding::Decoder4;
+use encoding::{
+    self, BytesEncoder, CompactSizeDecoder, CompactSizeDecoderError, CompactSizeEncoder, Decoder,
+    Encodable, Encoder, Encoder2,
+};
 #[cfg(feature = "hex")]
-use hex::{error::HexToBytesError, FromHex};
-use internals::compact_size;
+use hex::DecodeVariableLengthBytesError;
 use internals::slice::SliceExt;
 use internals::wrap_debug::WrapDebug;
+use internals::{compact_size, write_err};
 
 use crate::prelude::{Box, Vec};
+#[cfg(doc)]
+use crate::TxIn;
 
 /// The Witness is the data used to unlock bitcoin since the [SegWit upgrade].
 ///
@@ -31,12 +40,14 @@ use crate::prelude::{Box, Vec};
 pub struct Witness {
     /// Contains the witness `Vec<Vec<u8>>` serialization.
     ///
-    /// Does not include the initial varint indicating the number of elements. Each element however,
-    /// does include a varint indicating the element length. The number of elements is stored in
-    /// `witness_elements`.
+    /// Does not include the initial length prefix indicating the number of elements. Each element
+    /// however, does include a [`CompactSize`] indicating the element length. The number of
+    /// elements is stored in `witness_elements`.
     ///
     /// Concatenated onto the end of `content` is the index area. This is a `4 * witness_elements`
     /// bytes area which stores the index of the start of each witness item.
+    ///
+    /// [`CompactSize`]: <https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer>
     content: Vec<u8>,
 
     /// The number of elements in the witness.
@@ -56,24 +67,7 @@ impl Witness {
     /// Constructs a new empty [`Witness`].
     #[inline]
     pub const fn new() -> Self {
-        Witness { content: Vec::new(), witness_elements: 0, indices_start: 0 }
-    }
-
-    /// Constructs a new [`Witness`] from inner parts.
-    ///
-    /// This function leaks implementation details of the `Witness`, as such it is unstable and
-    /// should not be relied upon (it is primarily provided for use in `rust-bitcoin`).
-    ///
-    /// UNSTABLE: This function may change, break, or disappear in any release.
-    #[inline]
-    #[doc(hidden)]
-    #[allow(non_snake_case)] // Because of `__unstable`.
-    pub fn from_parts__unstable(
-        content: Vec<u8>,
-        witness_elements: usize,
-        indices_start: usize,
-    ) -> Self {
-        Witness { content, witness_elements, indices_start }
+        Self { content: Vec::new(), witness_elements: 0, indices_start: 0 }
     }
 
     /// Constructs a new [`Witness`] object from a slice of bytes slices where each slice is a witness item.
@@ -97,7 +91,7 @@ impl Witness {
             cursor += elem.as_ref().len();
         }
 
-        Witness { witness_elements, content, indices_start: content_size }
+        Self { witness_elements, content, indices_start: content_size }
     }
 
     /// Convenience method to create an array of byte-arrays from this witness.
@@ -111,15 +105,19 @@ impl Witness {
     /// Returns a struct implementing [`Iterator`].
     #[must_use = "iterators are lazy and do nothing unless consumed"]
     #[inline]
-    pub fn iter(&self) -> Iter {
+    pub fn iter(&self) -> Iter<'_> {
         Iter { inner: self.content.as_slice(), indices_start: self.indices_start, current_index: 0 }
     }
 
     /// Returns the number of elements this witness holds.
     #[inline]
-    pub fn len(&self) -> usize { self.witness_elements }
+    pub const fn len(&self) -> usize { self.witness_elements }
 
     /// Returns the number of bytes this witness contributes to a transactions total size.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
     pub fn size(&self) -> usize {
         let mut size: usize = 0;
 
@@ -135,7 +133,7 @@ impl Witness {
         size
     }
 
-    /// Clear the witness.
+    /// Clears the witness.
     #[inline]
     pub fn clear(&mut self) {
         self.content.clear();
@@ -143,13 +141,13 @@ impl Witness {
         self.indices_start = 0;
     }
 
-    /// Push a new element on the witness, requires an allocation.
+    /// Pushes a new element on the witness, requires an allocation.
     #[inline]
     pub fn push<T: AsRef<[u8]>>(&mut self, new_element: T) {
         self.push_slice(new_element.as_ref());
     }
 
-    /// Push a new element slice onto the witness stack.
+    /// Pushes a new element slice onto the witness stack.
     fn push_slice(&mut self, new_element: &[u8]) {
         self.witness_elements += 1;
         let previous_content_end = self.indices_start;
@@ -215,9 +213,7 @@ impl Witness {
 
         let mut slice = &self.content[pos..]; // Start of element.
         let element_len = compact_size::decode_unchecked(&mut slice);
-        // Compact size should always fit into a u32 because of `MAX_SIZE` in Core.
-        // ref: https://github.com/rust-bitcoin/rust-bitcoin/issues/3264
-        let end = element_len as usize;
+        let end = cast_to_usize_if_valid(element_len)?;
         Some(&slice[..end])
     }
 
@@ -227,14 +223,14 @@ impl Witness {
     ///
     /// This function will return an error if any of the hex strings are invalid.
     #[cfg(feature = "hex")]
-    pub fn from_hex<I, T>(iter: I) -> Result<Self, HexToBytesError>
+    pub fn from_hex<I, T>(iter: I) -> Result<Self, DecodeVariableLengthBytesError>
     where
         I: IntoIterator<Item = T>,
         T: AsRef<str>,
     {
         let result = iter
             .into_iter()
-            .map(|hex_str| Vec::from_hex(hex_str.as_ref()))
+            .map(|hex_str| crate::hex::decode_to_vec(hex_str.as_ref()))
             .collect::<Result<Vec<_>, _>>()?;
 
         Ok(Self::from_slice(&result))
@@ -251,11 +247,248 @@ fn encode_cursor(bytes: &mut [u8], start_of_indices: usize, index: usize, value:
         .copy_from_slice(&u32::to_ne_bytes(value.try_into().expect("larger than u32")));
 }
 
-// This is duplicated in `bitcoin::blockdata::witness`, if you change them do so over there also.
 #[inline]
 fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<usize> {
     let start = start_of_indices + index * 4;
-    bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes) as usize)
+    let pos = bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes))?;
+    usize::try_from(pos).ok()
+}
+
+/// The encoder for the [`Witness`] type.
+pub struct WitnessEncoder<'a>(Encoder2<CompactSizeEncoder, BytesEncoder<'a>>);
+
+impl Encodable for Witness {
+    type Encoder<'a>
+        = WitnessEncoder<'a>
+    where
+        Self: 'a;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let num_elements = CompactSizeEncoder::new(self.len());
+        let witness_elements =
+            BytesEncoder::without_length_prefix(&self.content[..self.indices_start]);
+
+        WitnessEncoder(Encoder2::new(num_elements, witness_elements))
+    }
+}
+
+impl Encoder for WitnessEncoder<'_> {
+    #[inline]
+    fn current_chunk(&self) -> &[u8] { self.0.current_chunk() }
+
+    #[inline]
+    fn advance(&mut self) -> bool { self.0.advance() }
+}
+
+/// The decoder for the [`Witness`] type.
+#[cfg(feature = "alloc")]
+pub struct WitnessDecoder {
+    /// The single buffer that will become the Witness content.
+    /// The index entries are written at the beginning, then rotated in [`Self::end`].
+    content: Vec<u8>,
+    /// Current write position in the content buffer.
+    cursor: usize,
+    /// Decoder for the initial witness element count.
+    witness_count_decoder: CompactSizeDecoder,
+    /// Total number of witness elements to decode (None until initial count is read).
+    witness_elements: Option<usize>,
+    /// Index of the current element being decoded.
+    element_idx: usize,
+    /// Decoder for the current element's length.
+    element_length_decoder: CompactSizeDecoder,
+    /// Bytes remaining to read for the current element's data.
+    /// - `None` means we're currently reading the length.
+    /// - `Some(n)` means we're reading element data with `n` bytes remaining.
+    element_bytes_remaining: Option<usize>,
+}
+
+impl WitnessDecoder {
+    /// Constructs a new witness decoder.
+    pub const fn new() -> Self {
+        Self {
+            content: Vec::new(),
+            cursor: 0,
+            witness_elements: None,
+            witness_count_decoder: CompactSizeDecoder::new(),
+            element_idx: 0,
+            element_length_decoder: CompactSizeDecoder::new(),
+            element_bytes_remaining: None,
+        }
+    }
+
+    /// Resizes the content buffer if needed, doubling the size each time.
+    fn resize_if_needed(&mut self, required_len: usize) {
+        if required_len >= self.content.len() {
+            let mut new_len = self.content.len().max(1);
+            while new_len <= required_len {
+                new_len *= 2;
+            }
+            self.content.resize(new_len, 0);
+        }
+    }
+}
+
+impl Default for WitnessDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl Decoder for WitnessDecoder {
+    type Output = Witness;
+    type Error = WitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        use {WitnessDecoderError as E, WitnessDecoderErrorInner as Inner};
+
+        // Read initial witness element count.
+        if self.witness_elements.is_none() {
+            if self
+                .witness_count_decoder
+                .push_bytes(bytes)
+                .map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+            {
+                return Ok(true);
+            }
+            // Take ownership of the decoder in order to consume it.
+            let decoder = core::mem::take(&mut self.witness_count_decoder);
+            let witness_elements = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+            self.witness_elements = Some(witness_elements);
+
+            // Short circuit for zero witness elements.
+            if witness_elements == 0 {
+                return Ok(false);
+            }
+
+            // Allocate space for the index and buffer. The buffer
+            // is initialized to 128 bytes which should be large enough
+            // to cover most witnesses, the typical pubkey + signature
+            // and some overhead (e.g. P2WPKH witness is ~100 bytes),
+            // without reallocating.
+            let witness_index_space = witness_elements * 4;
+            self.cursor = witness_index_space;
+            self.content = alloc::vec![0u8; self.cursor + 128];
+        }
+
+        let Some(witness_elements) = self.witness_elements else {
+            unreachable!("witness_elements must be Some after initial read")
+        };
+        let witness_index_space = witness_elements * 4;
+
+        // Read witness elements.
+        loop {
+            // Check if we're done processing all elements.
+            if self.element_idx >= witness_elements {
+                return Ok(false);
+            }
+
+            if bytes.is_empty() {
+                return Ok(true);
+            }
+
+            // If we have some bytes to read, then reading element data.
+            // Else we are reading the element's length.
+            if let Some(bytes_to_read) = self.element_bytes_remaining {
+                let copy_len = bytes.len().min(bytes_to_read);
+
+                // Ensure we have enough space.
+                let required_len = self.cursor + copy_len;
+                self.resize_if_needed(required_len);
+
+                self.content[self.cursor..self.cursor + copy_len]
+                    .copy_from_slice(&bytes[..copy_len]);
+                self.cursor += copy_len;
+                *bytes = &bytes[copy_len..];
+                let remaining = bytes_to_read - copy_len;
+
+                if remaining == 0 {
+                    // Element complete, move to next element.
+                    self.element_idx += 1;
+                    self.element_bytes_remaining = None;
+                } else {
+                    self.element_bytes_remaining = Some(remaining);
+                }
+            } else {
+                if self
+                    .element_length_decoder
+                    .push_bytes(bytes)
+                    .map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+                {
+                    return Ok(true);
+                }
+
+                // Take ownership of the decoder so we can consume it.
+                let decoder = core::mem::take(&mut self.element_length_decoder);
+                let element_length = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+
+                // Store the element position in the index.
+                let position_after_rotation = self.cursor - witness_index_space;
+                encode_cursor(&mut self.content, 0, self.element_idx, position_after_rotation);
+
+                // Re-encode the length back into the buffer.
+                let encoded_size = compact_size::encoded_size(element_length);
+                let required_len = self.cursor + encoded_size + element_length;
+                self.resize_if_needed(required_len);
+                let encoded_compact_size = compact_size::encode(element_length);
+                self.content[self.cursor..self.cursor + encoded_size]
+                    .copy_from_slice(&encoded_compact_size);
+                self.cursor += encoded_size;
+
+                if element_length == 0 {
+                    // Complete immediately for zero-length element to
+                    // avoid incorrectly signaling "need more data".
+                    self.element_idx += 1;
+                    self.element_bytes_remaining = None;
+                } else {
+                    self.element_bytes_remaining = Some(element_length);
+                }
+            }
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        use {WitnessDecoderError as E, WitnessDecoderErrorInner as Inner};
+
+        let Some(witness_elements) = self.witness_elements else {
+            // Never read the witness element count.
+            return Err(E(Inner::UnexpectedEof(UnexpectedEofError { missing_elements: 0 })));
+        };
+
+        let remaining = witness_elements - self.element_idx;
+
+        if remaining == 0 {
+            // Truncate to actual content length (remove unused allocated space).
+            self.content.truncate(self.cursor);
+
+            // Rotate the index area from beginning to end.
+            let witness_index_space = witness_elements * 4;
+            self.content.rotate_left(witness_index_space);
+
+            Ok(Witness {
+                content: self.content,
+                witness_elements,
+                indices_start: self.cursor - witness_index_space,
+            })
+        } else {
+            Err(E(Inner::UnexpectedEof(UnexpectedEofError { missing_elements: remaining })))
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        if self.witness_elements.is_none() {
+            // Reading witness count (haven't started processing elements yet).
+            self.witness_count_decoder.read_limit()
+        } else {
+            // Reading an element.
+            match self.element_bytes_remaining {
+                None => self.element_length_decoder.read_limit(),
+                Some(remaining) => remaining,
+            }
+        }
+    }
+}
+
+impl encoding::Decodable for Witness {
+    type Decoder = WitnessDecoder;
+    fn decoder() -> Self::Decoder { WitnessDecoder::default() }
 }
 
 // Note: we use `Borrow` in the following `PartialEq` impls specifically because of its additional
@@ -334,7 +567,7 @@ impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for alloc::sync::Arc<[T]>
 /// Debug implementation that displays the witness as a structured output containing:
 /// - Number of witness elements
 /// - Total bytes across all elements
-/// - List of hex-encoded witness elements if `hex` features is enabled.
+/// - List of hex-encoded witness elements if `hex` feature is enabled.
 #[allow(clippy::missing_fields_in_debug)] // We don't want to show `indices_start`.
 impl fmt::Debug for Witness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -348,7 +581,9 @@ impl fmt::Debug for Witness {
                 &WrapDebug(|f| {
                     #[cfg(feature = "hex")]
                     {
-                        f.debug_list().entries(self.iter().map(hex::DisplayHex::as_hex)).finish()
+                        f.debug_list()
+                            .entries(self.iter().map(hex_unstable::DisplayHex::as_hex))
+                            .finish()
                     }
                     #[cfg(not(feature = "hex"))]
                     {
@@ -383,9 +618,7 @@ impl<'a> Iterator for Iter<'a> {
         let index = decode_cursor(self.inner, self.indices_start, self.current_index)?;
         let mut slice = &self.inner[index..]; // Start of element.
         let element_len = compact_size::decode_unchecked(&mut slice);
-        // Compact size should always fit into a u32 because of `MAX_SIZE` in Core.
-        // ref: https://github.com/rust-bitcoin/rust-bitcoin/issues/3264
-        let end = element_len as usize;
+        let end = cast_to_usize_if_valid(element_len)?;
         self.current_index += 1;
         Some(&slice[..end])
     }
@@ -459,7 +692,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
                 self,
                 mut a: A,
             ) -> Result<Self::Value, A::Error> {
-                use hex::{FromHex, HexToBytesError as E};
+                use hex_unstable::{FromHex, HexToBytesError as E};
                 use serde::de::{self, Unexpected};
 
                 let mut ret = match a.size_hint() {
@@ -493,69 +726,69 @@ impl<'de> serde::Deserialize<'de> for Witness {
             deserializer.deserialize_seq(Visitor)
         } else {
             let vec: Vec<Vec<u8>> = serde::Deserialize::deserialize(deserializer)?;
-            Ok(Witness::from_slice(&vec))
+            Ok(Self::from_slice(&vec))
         }
     }
 }
 
 impl From<Vec<Vec<u8>>> for Witness {
     #[inline]
-    fn from(vec: Vec<Vec<u8>>) -> Self { Witness::from_slice(&vec) }
+    fn from(vec: Vec<Vec<u8>>) -> Self { Self::from_slice(&vec) }
 }
 
 impl From<&[&[u8]]> for Witness {
     #[inline]
-    fn from(slice: &[&[u8]]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[&[u8]]) -> Self { Self::from_slice(slice) }
 }
 
 impl From<&[Vec<u8>]> for Witness {
     #[inline]
-    fn from(slice: &[Vec<u8>]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[Vec<u8>]) -> Self { Self::from_slice(slice) }
 }
 
 impl From<Vec<&[u8]>> for Witness {
     #[inline]
-    fn from(vec: Vec<&[u8]>) -> Self { Witness::from_slice(&vec) }
+    fn from(vec: Vec<&[u8]>) -> Self { Self::from_slice(&vec) }
 }
 
 impl<const N: usize> From<[&[u8]; N]> for Witness {
     #[inline]
-    fn from(arr: [&[u8]; N]) -> Self { Witness::from_slice(&arr) }
+    fn from(arr: [&[u8]; N]) -> Self { Self::from_slice(&arr) }
 }
 
 impl<const N: usize> From<&[&[u8]; N]> for Witness {
     #[inline]
-    fn from(arr: &[&[u8]; N]) -> Self { Witness::from_slice(arr) }
+    fn from(arr: &[&[u8]; N]) -> Self { Self::from_slice(arr) }
 }
 
 impl<const N: usize> From<&[[u8; N]]> for Witness {
     #[inline]
-    fn from(slice: &[[u8; N]]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[[u8; N]]) -> Self { Self::from_slice(slice) }
 }
 
 impl<const N: usize> From<&[&[u8; N]]> for Witness {
     #[inline]
-    fn from(slice: &[&[u8; N]]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[&[u8; N]]) -> Self { Self::from_slice(slice) }
 }
 
 impl<const N: usize, const M: usize> From<[[u8; M]; N]> for Witness {
     #[inline]
-    fn from(slice: [[u8; M]; N]) -> Self { Witness::from_slice(&slice) }
+    fn from(slice: [[u8; M]; N]) -> Self { Self::from_slice(&slice) }
 }
 
 impl<const N: usize, const M: usize> From<&[[u8; M]; N]> for Witness {
     #[inline]
-    fn from(slice: &[[u8; M]; N]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[[u8; M]; N]) -> Self { Self::from_slice(slice) }
 }
 
 impl<const N: usize, const M: usize> From<[&[u8; M]; N]> for Witness {
     #[inline]
-    fn from(slice: [&[u8; M]; N]) -> Self { Witness::from_slice(&slice) }
+    fn from(slice: [&[u8; M]; N]) -> Self { Self::from_slice(&slice) }
 }
 
 impl<const N: usize, const M: usize> From<&[&[u8; M]; N]> for Witness {
     #[inline]
-    fn from(slice: &[&[u8; M]; N]) -> Self { Witness::from_slice(slice) }
+    fn from(slice: &[&[u8; M]; N]) -> Self { Self::from_slice(slice) }
 }
 
 impl Default for Witness {
@@ -563,36 +796,100 @@ impl Default for Witness {
     fn default() -> Self { Self::new() }
 }
 
+/// An error when consensus decoding a [`Witness`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WitnessDecoderError(WitnessDecoderErrorInner);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum WitnessDecoderErrorInner {
+    /// Error decoding the vector length prefix.
+    LengthPrefixDecode(CompactSizeDecoderError),
+    /// Not enough bytes given to decoder.
+    UnexpectedEof(UnexpectedEofError),
+}
+
+impl From<Infallible> for WitnessDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl fmt::Display for WitnessDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use WitnessDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => write_err!(f, "vec decoder error"; e),
+            E::UnexpectedEof(ref e) => write_err!(f, "decoder error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WitnessDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use WitnessDecoderErrorInner as E;
+
+        match self.0 {
+            E::LengthPrefixDecode(ref e) => Some(e),
+            E::UnexpectedEof(ref e) => Some(e),
+        }
+    }
+}
+
+/// Not enough witness elements (bytes) given to decoder.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UnexpectedEofError {
+    /// Number of elements missing to complete decoder.
+    missing_elements: usize,
+}
+
+impl core::fmt::Display for UnexpectedEofError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "not enough witness elements for decoder, missing {}", self.missing_elements)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnexpectedEofError {}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Witness {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let arbitrary_bytes = Vec::<Vec<u8>>::arbitrary(u)?;
-        Ok(Witness::from_slice(&arbitrary_bytes))
+        Ok(Self::from_slice(&arbitrary_bytes))
+    }
+}
+
+/// Cast a decoded length prefix to a `usize`.
+///
+/// This function is basically just defensive. For all sane use cases the length prefix should be
+/// less than `MAX_VEC_SIZE` (on a 32-bit machine). If the value is bigger that `u16::MAX` and we
+/// are on a 16-bit machine you'll likely hit an error later anyway, better to just check it now.
+///
+/// # 16-bits
+///
+/// The compact size may be bigger than what can be represented in a `usize` on a 16-bit machine but
+/// this shouldn't happen if we created the witness because one would get an OOM error before that.
+fn cast_to_usize_if_valid(n: u64) -> Option<usize> {
+    /// Maximum size, in bytes, of a vector we are allowed to decode.
+    const MAX_VEC_SIZE: u64 = 4_000_000;
+
+    if n > MAX_VEC_SIZE {
+        return None;
     }
+
+    usize::try_from(n).ok()
 }
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    #[cfg(feature = "alloc")]
+    use alloc::vec;
 
-    // Appends all the indices onto the end of a list of elements.
-    fn append_u32_vec(elements: &[u8], indices: &[u32]) -> Vec<u8> {
-        let mut v = elements.to_vec();
-        for &num in indices {
-            v.extend_from_slice(&num.to_ne_bytes());
-        }
-        v
-    }
+    use super::*;
 
     // A witness with a single element that is empty (zero length).
     fn single_empty_element() -> Witness { Witness::from([[0u8; 0]]) }
 
-    #[test]
-    fn witness_debug_can_display_empty_element() {
-        let witness = single_empty_element();
-        println!("{:?}", witness);
-    }
-
     #[test]
     fn witness_single_empty_element() {
         let mut got = Witness::new();
@@ -687,19 +984,6 @@ mod test {
         }
     }
 
-    #[test]
-    fn witness_from_parts() {
-        let elements = [1u8, 11, 2, 21, 22];
-        let witness_elements = 2;
-        let content = append_u32_vec(&elements, &[0, 2]);
-        let indices_start = elements.len();
-        let witness =
-            Witness::from_parts__unstable(content.clone(), witness_elements, indices_start);
-        assert_eq!(witness.get(0).unwrap(), [11_u8]);
-        assert_eq!(witness.get(1).unwrap(), [21_u8, 22]);
-        assert_eq!(witness.size(), 6);
-    }
-
     #[test]
     fn witness_from_impl() {
         // Test From implementations with the same 2 elements
@@ -768,8 +1052,6 @@ mod test {
             }};
         }
 
-        let witness = Witness::from_slice(&[DATA_1, DATA_2]);
-
         // &[T]
         let container: &[&[u8]] = &[EMPTY_BYTES];
         let different: &[&[u8]] = &[DATA_1];
@@ -792,22 +1074,22 @@ mod test {
         // Vec<T>
         let container: Vec<&[u8]> = vec![DATA_1, DATA_2];
         let different: Vec<&[u8]> = vec![DATA_2, DATA_1];
-        ck!(witness.clone(), container, different);
+        ck!(Witness::from(container.as_slice()), container, different);
 
         // Box<[T]>
         let container: Box<[&[u8]]> = vec![DATA_1, DATA_2].into_boxed_slice();
         let different: Box<[&[u8]]> = vec![DATA_2, DATA_1].into_boxed_slice();
-        ck!(witness.clone(), container, different);
+        ck!(Witness::from(&*container), container, different);
 
         // Rc<[T]>
         let container: alloc::rc::Rc<[&[u8]]> = vec![DATA_1, DATA_2].into();
         let different: alloc::rc::Rc<[&[u8]]> = vec![DATA_2, DATA_1].into();
-        ck!(witness.clone(), container, different);
+        ck!(Witness::from(&*container), container, different);
 
         // Arc<[T]>
         let container: alloc::sync::Arc<[&[u8]]> = vec![DATA_1, DATA_2].into();
         let different: alloc::sync::Arc<[&[u8]]> = vec![DATA_2, DATA_1].into();
-        ck!(witness, container, different);
+        ck!(Witness::from(&*container), container, different);
     }
 
     #[test]
@@ -849,8 +1131,8 @@ mod test {
     fn serde_bincode_roundtrips() {
         let original = arbitrary_witness();
         let ser = bincode::serialize(&original).unwrap();
-        let rinsed: Witness = bincode::deserialize(&ser).unwrap();
-        assert_eq!(rinsed, original);
+        let roundtrip: Witness = bincode::deserialize(&ser).unwrap();
+        assert_eq!(roundtrip, original);
     }
 
     #[test]
@@ -858,8 +1140,8 @@ mod test {
     fn serde_human_roundtrips() {
         let original = arbitrary_witness();
         let ser = serde_json::to_string(&original).unwrap();
-        let rinsed: Witness = serde_json::from_str(&ser).unwrap();
-        assert_eq!(rinsed, original);
+        let roundtrip: Witness = serde_json::from_str(&ser).unwrap();
+        assert_eq!(roundtrip, original);
     }
 
     #[test]
@@ -903,8 +1185,8 @@ mod test {
         assert!(witness4.is_empty());
     }
 
-    #[cfg(feature = "hex")]
     #[test]
+    #[cfg(feature = "hex")]
     fn test_from_hex() {
         let hex_strings = [
             "30440220703350f1c8be5b41b4cb03b3b680c4f3337f987514a6b08e16d5d9f81e9b5f72022018fb269ba5b82864c0e1edeaf788829eb332fe34a859cc1f99c4a02edfb5d0df01",
@@ -914,4 +1196,280 @@ mod test {
         let witness = Witness::from_hex(hex_strings).unwrap();
         assert_eq!(witness.len(), 2);
     }
+
+    #[test]
+    fn encode() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let bytes3 = [6u8, 7, 8, 9];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        // Use FromIterator directly
+        let witness = Witness::from_iter(data);
+
+        let want = [0x03, 0x03, 0x01, 0x02, 0x03, 0x02, 0x04, 0x05, 0x04, 0x06, 0x07, 0x08, 0x09];
+        let got = encoding::encode_to_vec(&witness);
+
+        assert_eq!(&got, &want);
+    }
+
+    #[test]
+    fn encodes_using_correct_chunks() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let data = [&bytes1[..], &bytes2[..]];
+
+        // Use FromIterator directly
+        let witness = Witness::from_iter(data);
+
+        // Should have length prefix chunk, then the content slice, then exhausted.
+        let mut encoder = witness.encoder();
+
+        assert_eq!(encoder.current_chunk(), &[2u8][..]);
+        assert!(encoder.advance());
+
+        // We don't encode one element at a time, rather we encode the whole content slice at once.
+        assert_eq!(encoder.current_chunk(), &[3u8, 1, 2, 3, 2, 4, 5][..]);
+        assert!(!encoder.advance());
+        assert!(encoder.current_chunk().is_empty());
+    }
+
+    #[test]
+    fn encode_empty() {
+        let witness = Witness::default();
+
+        let want = [0x00];
+        let got = encoding::encode_to_vec(&witness);
+
+        assert_eq!(&got, &want);
+    }
+
+    #[cfg(feature = "alloc")]
+    fn witness_test_case() -> (Witness, Vec<u8>) {
+        let bytes1 = [1u8];
+        let bytes2 = [2u8, 3];
+        let bytes3 = [4u8, 5, 6];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        let witness = Witness::from_iter(data);
+
+        #[rustfmt::skip]
+        let encoded = vec![
+            0x03_u8,
+            0x01, 0x01,
+            0x02, 0x02, 0x03,
+            0x03, 0x04, 0x05, 0x06
+        ];
+
+        (witness, encoded)
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_witness_one_single_call() {
+        let (want, encoded) = witness_test_case();
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        decoder.push_bytes(&mut slice).unwrap();
+
+        let got = decoder.end().unwrap();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[allow(clippy::many_single_char_names)]
+    fn decode_witness_many_calls() {
+        let (want, encoded) = witness_test_case();
+
+        let mut decoder = WitnessDecoder::new();
+
+        let mut a = &encoded.as_slice()[0..1]; // [3]
+        let mut b = &encoded.as_slice()[1..2]; // [1]
+        let mut c = &encoded.as_slice()[2..5]; // [1, 2, 2]
+        let mut d = &encoded.as_slice()[5..6]; // [3]
+        let mut e = &encoded.as_slice()[6..7]; // [3]
+        let mut f = &encoded.as_slice()[7..9]; // [4, 5]
+        let mut g = &encoded.as_slice()[9..]; // [6]
+
+        decoder.push_bytes(&mut a).unwrap();
+        decoder.push_bytes(&mut b).unwrap();
+        decoder.push_bytes(&mut c).unwrap();
+        decoder.push_bytes(&mut d).unwrap();
+        decoder.push_bytes(&mut e).unwrap();
+        decoder.push_bytes(&mut f).unwrap();
+        decoder.push_bytes(&mut g).unwrap();
+
+        let got = decoder.end().unwrap();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_max_length() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(compact_size::encode(1usize).as_slice());
+        encoded.extend_from_slice(compact_size::encode(4_000_000usize).as_slice());
+        encoded.resize(encoded.len() + 4_000_000, 0u8);
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        decoder.push_bytes(&mut slice).unwrap();
+        let witness = decoder.end().unwrap();
+        assert_eq!(witness[0].len(), 4_000_000);
+
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(compact_size::encode(1usize).as_slice());
+        encoded.extend_from_slice(compact_size::encode(4_000_001usize).as_slice());
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        let err = decoder.push_bytes(&mut slice).unwrap_err();
+        assert!(matches!(
+            err,
+            WitnessDecoderError(WitnessDecoderErrorInner::LengthPrefixDecode(_))
+        ));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_empty_witness() {
+        // Witness with 0 elements.
+        let encoded = vec![0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 0);
+        assert!(witness.is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_single_element() {
+        // Witness with 1 element containing [0xAB, 0xCD].
+        let encoded = vec![0x01, 0x02, 0xAB, 0xCD];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[0xABu8, 0xCD][..]);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_empty_element() {
+        // Witness with 1 element that is empty (0 bytes).
+        let encoded = vec![0x01, 0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[] as &[u8]);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_multiple_empty_elements() {
+        // Witness with 3 empty elements.
+        let encoded = vec![0x03, 0x00, 0x00, 0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 3);
+        assert_eq!(&witness[0], &[] as &[u8]);
+        assert_eq!(&witness[1], &[] as &[u8]);
+        assert_eq!(&witness[2], &[] as &[u8]);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_incomplete_witness_count() {
+        // 3-byte compact size but only provide 2 bytes.
+        let encoded = vec![0xFD, 0x03];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_incomplete_element_length() {
+        // Witness count = 1, but element length is incomplete.
+        let encoded = vec![0x01, 0xFD, 0x05]; // Element length should be 3 bytes.
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_incomplete_element_data() {
+        // Witness count = 1, element length = 5, but only 3 bytes of data provided.
+        let encoded = vec![0x01, 0x05, 0xAA, 0xBB, 0xCC];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_buffer_resizing() {
+        // Create a witness with elements larger than initial 128-byte allocation.
+        let large_element = vec![0xFF; 500];
+        let mut encoded = vec![0x02];
+        encoded.extend_from_slice(&[0xFD, 0xF4, 0x01]);
+        encoded.extend_from_slice(&large_element);
+        encoded.extend_from_slice(&[0xFD, 0xF4, 0x01]);
+        encoded.extend_from_slice(&large_element);
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        assert!(!decoder.push_bytes(&mut slice).unwrap());
+
+        let witness = decoder.end().unwrap();
+        assert_eq!(witness.len(), 2);
+        assert_eq!(&witness[0], large_element.as_slice());
+        assert_eq!(&witness[1], large_element.as_slice());
+    }
+
+    #[test]
+    fn size_matches_encoding_length() {
+        let empty = Witness::new();
+        assert_eq!(empty.size(), encoding::encode_to_vec(&empty).len());
+
+        let mut witness = Witness::new();
+        witness.push([0u8; 0]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+        witness.push([0u8; 252]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+        witness.push([0u8; 253]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+    }
 }
diff --git a/primitives/tests/api.rs b/primitives/tests/api.rs
index 913089cdbd..379b186011 100644
--- a/primitives/tests/api.rs
+++ b/primitives/tests/api.rs
@@ -2,7 +2,7 @@
 
 //! Test the API surface of `primitives`.
 //!
-//! The point of these tests are to check the API surface as opposed to test the API functionality.
+//! The point of these tests is to check the API surface as opposed to test the API functionality.
 //!
 //! ref: <https://rust-lang.github.io/api-guidelines/about.html>
 
@@ -17,8 +17,9 @@ use arbitrary::Arbitrary;
 use bitcoin_primitives::block::{Checked, Unchecked};
 use bitcoin_primitives::script::{self, ScriptHash, WScriptHash};
 use bitcoin_primitives::{
-    absolute, block, merkle_tree, pow, relative, transaction, witness, OutPoint, Script, ScriptBuf,
-    Sequence, Transaction, TxIn, TxOut, Txid, Witness, Wtxid,
+    absolute, block, merkle_tree, pow, relative, transaction, witness, OutPoint, RedeemScript,
+    RedeemScriptBuf, ScriptPubKey, ScriptPubKeyBuf, ScriptSig, ScriptSigBuf, Sequence, TapScript,
+    TapScriptBuf, Transaction, TxIn, TxOut, Txid, Witness, WitnessScript, WitnessScriptBuf, Wtxid,
 };
 use hashes::sha256t;
 
@@ -43,10 +44,18 @@ struct Structs<'a> {
     g: merkle_tree::TxMerkleNode,
     h: merkle_tree::WitnessMerkleNode,
     i: pow::CompactTarget,
-    j: &'a Script,
+    j1: &'a RedeemScript,
+    j2: &'a ScriptPubKey,
+    j3: &'a ScriptSig,
+    j4: &'a TapScript,
+    j5: &'a WitnessScript,
     k: ScriptHash,
     l: WScriptHash,
-    m: ScriptBuf,
+    m1: RedeemScriptBuf,
+    m2: ScriptPubKeyBuf,
+    m3: ScriptSigBuf,
+    m4: TapScriptBuf,
+    m5: WitnessScriptBuf,
     n: Sequence,
     o: Transaction,
     p: TxIn,
@@ -59,11 +68,15 @@ struct Structs<'a> {
     // w: witness::Iter<'a>,
 }
 
-static SCRIPT: ScriptBuf = ScriptBuf::new();
+static REDEEM_SCRIPT: RedeemScriptBuf = RedeemScriptBuf::new();
+static SCRIPT_SIG: ScriptSigBuf = ScriptSigBuf::new();
+static SCRIPT_PUB_KEY: ScriptPubKeyBuf = ScriptPubKeyBuf::new();
+static TAP_SCRIPT: TapScriptBuf = TapScriptBuf::new();
+static WITNESS_SCRIPT: WitnessScriptBuf = WitnessScriptBuf::new();
 static BYTES: [u8; 32] = [0x00; 32];
 
 /// Public structs that derive common traits.
-// C-COMMON-TRAITS excluding `Debug, Default, Display, Ord, PartialOrd, Hash`.
+// C-COMMON-TRAITS excluding `Debug`, `Default`, `Display`, `Ord`, `PartialOrd`, `Hash`.
 #[derive(Clone, PartialEq, Eq)]
 struct CommonTraits {
     a: block::Block<Checked>,
@@ -78,7 +91,11 @@ struct CommonTraits {
     // j: &'a Script,
     k: ScriptHash,
     l: WScriptHash,
-    m: ScriptBuf,
+    m1: RedeemScriptBuf,
+    m2: ScriptPubKeyBuf,
+    m3: ScriptSigBuf,
+    m4: TapScriptBuf,
+    m5: WitnessScriptBuf,
     n: Sequence,
     o: Transaction,
     p: TxIn,
@@ -106,7 +123,11 @@ struct Clone<'a> {
     // j: &'a Script,
     k: ScriptHash,
     l: WScriptHash,
-    m: ScriptBuf,
+    m1: RedeemScriptBuf,
+    m2: ScriptPubKeyBuf,
+    m3: ScriptSigBuf,
+    m4: TapScriptBuf,
+    m5: WitnessScriptBuf,
     n: Sequence,
     o: Transaction,
     p: TxIn,
@@ -120,7 +141,7 @@ struct Clone<'a> {
 }
 
 /// Public structs that derive common traits.
-// C-COMMON-TRAITS excluding `Clone`, `Debug, `Default`, and `Display`
+// C-COMMON-TRAITS excluding `Clone`, `Debug`, `Default`, and `Display`
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
 struct Ord {
     // a: block::Block<Checked>,
@@ -135,7 +156,11 @@ struct Ord {
     // j: &'a Script,  // Doesn't implement `Clone`.
     k: ScriptHash,
     l: WScriptHash,
-    m: ScriptBuf,
+    m1: RedeemScriptBuf,
+    m2: ScriptPubKeyBuf,
+    m3: ScriptSigBuf,
+    m4: TapScriptBuf,
+    m5: WitnessScriptBuf,
     n: Sequence,
     o: Transaction,
     p: TxIn,
@@ -152,8 +177,16 @@ struct Ord {
 #[derive(Default, Debug, PartialEq, Eq)] // C-COMMON-TRAITS: `Default` (others just so we can test).
 struct Default {
     a: block::Version,
-    b: &'static Script,
-    c: ScriptBuf,
+    b1: &'static RedeemScript,
+    b2: &'static ScriptPubKey,
+    b3: &'static ScriptSig,
+    b4: &'static TapScript,
+    b5: &'static WitnessScript,
+    c1: RedeemScriptBuf,
+    c2: ScriptPubKeyBuf,
+    c3: ScriptSigBuf,
+    c4: TapScriptBuf,
+    c5: WitnessScriptBuf,
     d: Sequence,
     e: Witness,
 }
@@ -163,14 +196,12 @@ struct Default {
 #[derive(Debug, Clone, PartialEq, Eq)] // All public types implement Debug (C-DEBUG).
 struct Errors {
     a: transaction::ParseOutPointError,
-    b: relative::IncompatibleHeightError,
-    c: relative::IncompatibleTimeError,
-    d: relative::IncompatibleHeightError,
-    e: relative::IncompatibleTimeError,
-    f: relative::DisabledLockTimeError,
-    g: relative::DisabledLockTimeError,
-    h: script::RedeemScriptSizeError,
-    i: script::WitnessScriptSizeError,
+    b: relative::error::DisabledLockTimeError,
+    c: relative::error::IsSatisfiedByError,
+    d: relative::error::IsSatisfiedByHeightError,
+    e: relative::error::IsSatisfiedByTimeError,
+    f: script::RedeemScriptSizeError,
+    g: script::WitnessScriptSizeError,
 }
 
 #[test]
@@ -180,16 +211,25 @@ fn api_can_use_units_modules_from_crate_root() {
 
 #[test]
 fn api_can_use_units_types_from_crate_root() {
-    use bitcoin_primitives::{Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+    use bitcoin_primitives::{
+        Amount, BlockHeight, BlockHeightInterval, FeeRate, SignedAmount, Weight,
+    };
 }
 
 #[test]
 fn api_can_use_all_units_types_from_module_amount() {
     use bitcoin_primitives::amount::{
-        Amount, Denomination, Display, InputTooLargeError, InvalidCharacterError,
-        MissingDenominationError, MissingDigitsError, OutOfRangeError, ParseAmountError,
-        ParseDenominationError, ParseError, PossiblyConfusingDenominationError, SignedAmount,
-        TooPreciseError, UnknownDenominationError,
+        Amount, Denomination, Display, OutOfRangeError, ParseAmountError, ParseDenominationError,
+        ParseError, SignedAmount,
+    };
+}
+
+#[test]
+fn api_can_use_all_units_types_from_module_amount_error() {
+    use bitcoin_primitives::amount::error::{
+        InputTooLargeError, InvalidCharacterError, MissingDenominationError, MissingDigitsError,
+        OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
+        PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
     };
 }
 
@@ -203,24 +243,26 @@ fn api_can_use_modules_from_crate_root() {
 #[test]
 fn api_can_use_types_from_crate_root() {
     use bitcoin_primitives::{
-        Block, BlockHash, BlockHeader, BlockVersion, CompactTarget, OutPoint, Script, ScriptBuf,
-        Sequence, Transaction, TransactionVersion, TxIn, TxMerkleNode, TxOut, Txid, Witness,
-        WitnessCommitment, WitnessMerkleNode, Wtxid,
+        Block, BlockHash, BlockHeader, BlockVersion, CompactTarget, OutPoint, ScriptPubKey,
+        ScriptPubKeyBuf, ScriptSig, ScriptSigBuf, Sequence, Transaction, TransactionVersion, TxIn,
+        TxMerkleNode, TxOut, Txid, Witness, WitnessCommitment, WitnessMerkleNode, Wtxid,
     };
 }
 
 #[test]
 fn api_can_use_all_types_from_module_locktime() {
-    use bitcoin_primitives::locktime::relative::{
-        DisabledLockTimeError, IncompatibleHeightError, IncompatibleTimeError, LockTime,
+    use bitcoin_primitives::locktime::relative::error::{
+        DisabledLockTimeError, InvalidHeightError, InvalidTimeError,
     };
+    use bitcoin_primitives::locktime::relative::LockTime;
     use bitcoin_primitives::locktime::{absolute, relative};
 }
 
 #[test]
 fn api_can_use_all_types_from_module_script() {
     use bitcoin_primitives::script::{
-        RedeemScriptSizeError, Script, ScriptBuf, ScriptHash, WScriptHash, WitnessScriptSizeError,
+        RedeemScriptSizeError, ScriptHash, ScriptPubKey, ScriptPubKeyBuf, ScriptSig, ScriptSigBuf,
+        WScriptHash, WitnessScriptSizeError,
     };
 }
 
@@ -258,10 +300,18 @@ fn api_all_non_error_types_have_non_empty_debug() {
         merkle_tree::TxMerkleNode::from_byte_array(BYTES);
         merkle_tree::WitnessMerkleNode::from_byte_array(BYTES);
         pow::CompactTarget::from_consensus(0x1d00_ffff);
-        SCRIPT.as_script();
-        ScriptHash::from_script(&SCRIPT).unwrap();
-        WScriptHash::from_script(&SCRIPT).unwrap();
-        SCRIPT.clone();
+        REDEEM_SCRIPT.as_script();
+        SCRIPT_SIG.as_script();
+        SCRIPT_PUB_KEY.as_script();
+        TAP_SCRIPT.as_script();
+        WITNESS_SCRIPT.as_script();
+        ScriptHash::from_script(&REDEEM_SCRIPT).unwrap();
+        WScriptHash::from_script(&WITNESS_SCRIPT).unwrap();
+        REDEEM_SCRIPT.clone();
+        SCRIPT_SIG.clone();
+        SCRIPT_PUB_KEY.clone();
+        TAP_SCRIPT.clone();
+        WITNESS_SCRIPT.clone();
         Sequence::arbitrary(&mut u).unwrap();
         Transaction::arbitrary(&mut u).unwrap();
         TxIn::arbitrary(&mut u).unwrap();
@@ -296,8 +346,16 @@ fn regression_default() {
     let got: Default = Default::default();
     let want = Default {
         a: block::Version::NO_SOFT_FORK_SIGNALLING,
-        b: Script::from_bytes(&[]),
-        c: ScriptBuf::from_bytes(Vec::new()),
+        b1: RedeemScript::from_bytes(&[]),
+        b2: ScriptPubKey::from_bytes(&[]),
+        b3: ScriptSig::from_bytes(&[]),
+        b4: TapScript::from_bytes(&[]),
+        b5: WitnessScript::from_bytes(&[]),
+        c1: RedeemScriptBuf::from_bytes(Vec::new()),
+        c2: ScriptPubKeyBuf::from_bytes(Vec::new()),
+        c3: ScriptSigBuf::from_bytes(Vec::new()),
+        c4: TapScriptBuf::from_bytes(Vec::new()),
+        c5: WitnessScriptBuf::from_bytes(Vec::new()),
         d: Sequence::MAX,
         e: Witness::new(),
     };
diff --git a/rustfmt.toml b/rustfmt.toml
index 08c331b51c..c3f75bec4d 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -4,7 +4,7 @@ tab_spaces = 4
 newline_style = "Auto"
 indent_style = "Block"
 
-max_width = 100 # This is number of characters.
+max_width = 100 # This is the number of characters.
 # `use_small_heuristics` is ignored if the granular width config values are explicitly set.
 use_small_heuristics = "Max"    # "Max" == All granular width settings same as `max_width`.
 # # Granular width configuration settings. These are percentages of `max_width`.
diff --git a/units/CHANGELOG.md b/units/CHANGELOG.md
index c2f6a470f9..9601a973a2 100644
--- a/units/CHANGELOG.md
+++ b/units/CHANGELOG.md
@@ -1,8 +1,51 @@
-# Unreleased
-
-- TODO: Make a comment about `Amount::MAX_MONEY` including breaking serde
-
-- Use MAX_MONEY in serde regression test [#3950](https://github.com/rust-bitcoin/rust-bitcoin/pull/3950)
+# 1.0.0 - 2025-02-24
+
+BOOM! A long time in the making but here goes, our first 1.0 crate release.
+
+This changelog is a rolling description of everything that will eventually end up in `v1.0`.
+
+* Introduce limit to `Amount`
+  * Prepare to enforce `MAX_MONEY` invariant [#4164](https://github.com/rust-bitcoin/rust-bitcoin/pull/4164)
+  * Enforce `MAX_MONEY` invariant in amount types [#4157](https://github.com/rust-bitcoin/rust-bitcoin/pull/4157)
+* Allow underscores as separators in `Amount` values [#5309](https://github.com/rust-bitcoin/rust-bitcoin/pull/5309)
+* New `NumOpResult` type
+  * Introduce monadic `NumOpResult` type [#4007](https://github.com/rust-bitcoin/rust-bitcoin/pull/4007)
+  * Add impls for `NumOpResult` div and mul [#4337](https://github.com/rust-bitcoin/rust-bitcoin/pull/4337)
+  * Use `NumOpResult` instead of `Option` [#4428](https://github.com/rust-bitcoin/rust-bitcoin/pull/4428)
+  * Return `NumOpResult` when implementing `Div` [#4312](https://github.com/rust-bitcoin/rust-bitcoin/pull/4312)
+* Heavily modify `fee_rate` module:
+  * Make `FeeRate` use MvB internally [#4534](https://github.com/rust-bitcoin/rust-bitcoin/pull/4534)
+  * Add `FeeRate` addition and subtraction traits [#3381](https://github.com/rust-bitcoin/rust-bitcoin/pull/3381)
+  * Remove `Display`/`FromStr` for `FeeRate` [#4512](https://github.com/rust-bitcoin/rust-bitcoin/pull/4512)
+  * Implement `serde` modules for `FeeRate` [#3666](https://github.com/rust-bitcoin/rust-bitcoin/pull/3666)
+* Fix and improve `locktime` modules
+  * Modify locktime `serde` implementations [#4511](https://github.com/rust-bitcoin/rust-bitcoin/pull/4511)
+  * Improve lock times - fix off-by-one bug [#4468](https://github.com/rust-bitcoin/rust-bitcoin/pull/4468)
+  * Do lock time renames [#4462](https://github.com/rust-bitcoin/rust-bitcoin/pull/4462)
+* Make block-related types have private inner fields [#4508](https://github.com/rust-bitcoin/rust-bitcoin/pull/4508)
+* `Timestamp`/`BlockTime`
+  * Add `Timestamp` newtype [#4092](https://github.com/rust-bitcoin/rust-bitcoin/pull/4092)
+  * Rename then new `Timestamp` type to `BlockTime` [#4219](https://github.com/rust-bitcoin/rust-bitcoin/pull/4219)
+* Add µBTC as a recognized str form of a `MicroBitcoin` `Denomination` [#3943](https://github.com/rust-bitcoin/rust-bitcoin/pull/3943)
+* Remove `InputString` from the public API [#3905](https://github.com/rust-bitcoin/rust-bitcoin/pull/3905)
+* Hide the remaining public macros [#3867](https://github.com/rust-bitcoin/rust-bitcoin/pull/3867)
+* Change method return type for `to_unsigned()` [#3769](https://github.com/rust-bitcoin/rust-bitcoin/pull/3769)
+* Change parameter type used for whole bitcoin [#3744](https://github.com/rust-bitcoin/rust-bitcoin/pull/3744)
+* Add `Weight::to_kwu_ceil` [#3740](https://github.com/rust-bitcoin/rust-bitcoin/pull/3740)
+* Replace `String` with `InputString` [#3559](https://github.com/rust-bitcoin/rust-bitcoin/pull/3559)
+* Do not re-export doc hidden macros
+* Use the new `consensus_encoding` crate to re-write encoding logic.
+  * Decoders with phantoms [#5008](https://github.com/rust-bitcoin/rust-bitcoin/pull/5008)
+  * Improve the decoders [#5027](https://github.com/rust-bitcoin/rust-bitcoin/pull/5027)
+
+## Changes relate to error types
+
+* Close the hex parse errors [#3673](https://github.com/rust-bitcoin/rust-bitcoin/pull/3673)
+
+## Improved support for `Arbitrary`
+
+* Implement `Arbitrary` for `units` types [#3777](https://github.com/rust-bitcoin/rust-bitcoin/pull/3777)
+* Add `Arbitrary` to `Weight` [#3257](https://github.com/rust-bitcoin/rust-bitcoin/pull/3257)
 
 # 0.2.0 - 2024-09-18
 
@@ -65,4 +108,4 @@ The main types are:
 
 ## 0.0.0 - Placeholder release
 
-Empty crate to reserve the name on crates.io
\ No newline at end of file
+Empty crate to reserve the name on crates.io
diff --git a/units/Cargo.toml b/units/Cargo.toml
index 5134003cdd..9c255076b0 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "bitcoin-units"
-version = "0.2.0"
-authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+version = "1.0.0-rc.3"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>", "Tobin C. Harding <me@tobin.cc>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
 description = "Basic Bitcoin numeric units such as amount"
@@ -9,157 +9,31 @@ categories = ["cryptography::cryptocurrencies"]
 keywords = ["bitcoin", "newtypes", "no-std"]
 readme = "README.md"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.74.0"
 exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "internals/std"]
-alloc = ["internals/alloc","serde?/alloc"]
+std = ["alloc", "internals/std", "encoding?/std"]
+alloc = ["internals/alloc", "serde?/alloc", "encoding?/alloc"]
 
 [dependencies]
-internals = { package = "bitcoin-internals", path = "../internals" }
+encoding = { package = "bitcoin-consensus-encoding", path = "../consensus_encoding", version = "=1.0.0-rc.2", default-features = false, optional = true }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.1" }
 
-serde = { version = "1.0.103", default-features = false, features = ["derive"], optional = true }
-arbitrary = { version = "1.4", optional = true }
+serde = { version = "1.0.195", default-features = false, features = ["derive"], optional = true }
+arbitrary = { version = "1.4.1", optional = true }
 
 [dev-dependencies]
-internals = { package = "bitcoin-internals", path = "../internals", features = ["test-serde"] }
+internals = { package = "bitcoin-internals", path = "../internals", version = "0.4.0", features = ["test-serde"] }
 bincode = "1.3.1"
-serde_test = "1.0"
-serde_json = "1.0"
+serde = { version = "1.0.195", default-features = false, features = ["derive"] }
+serde_test = "1.0.19"
+serde_json = "1.0.68"
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
-
-[lints.clippy]
-# Exclude lints we don't think are valuable.
-needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
-manual_range_contains = "allow" # More readable than clippy's format.
-# Exhaustive list of pedantic clippy lints
-assigning_clones = "warn"
-bool_to_int_with_if = "warn"
-borrow_as_ptr = "warn"
-case_sensitive_file_extension_comparisons = "warn"
-cast_lossless = "warn"
-cast_possible_truncation = "allow" # All casts should include a code comment (except test code).
-cast_possible_wrap = "allow" # Same as above re code comment.
-cast_precision_loss = "warn"
-cast_ptr_alignment = "warn"
-cast_sign_loss = "allow" # All casts should include a code comment (except in test code).
-checked_conversions = "warn"
-cloned_instead_of_copied = "warn"
-copy_iterator = "warn"
-default_trait_access = "warn"
-doc_link_with_quotes = "warn"
-doc_markdown = "warn"
-empty_enum = "warn"
-enum_glob_use = "warn"
-expl_impl_clone_on_copy = "warn"
-explicit_deref_methods = "warn"
-explicit_into_iter_loop = "warn"
-explicit_iter_loop = "warn"
-filter_map_next = "warn"
-flat_map_option = "warn"
-float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
-fn_params_excessive_bools = "warn"
-from_iter_instead_of_collect = "warn"
-if_not_else = "warn"
-ignored_unit_patterns = "warn"
-implicit_clone = "warn"
-implicit_hasher = "warn"
-inconsistent_struct_constructor = "warn"
-index_refutable_slice = "warn"
-inefficient_to_string = "warn"
-inline_always = "warn"
-into_iter_without_iter = "warn"
-invalid_upcast_comparisons = "warn"
-items_after_statements = "warn"
-iter_filter_is_ok = "warn"
-iter_filter_is_some = "warn"
-iter_not_returning_iterator = "warn"
-iter_without_into_iter = "warn"
-large_digit_groups = "warn"
-large_futures = "warn"
-large_stack_arrays = "warn"
-large_types_passed_by_value = "warn"
-linkedlist = "warn"
-macro_use_imports = "warn"
-manual_assert = "warn"
-manual_instant_elapsed = "warn"
-manual_is_power_of_two = "warn"
-manual_is_variant_and = "warn"
-manual_let_else = "warn"
-manual_ok_or = "warn"
-manual_string_new = "warn"
-many_single_char_names = "warn"
-map_unwrap_or = "warn"
-match_bool = "allow" # Adds extra indentation and LOC.
-match_on_vec_items = "warn"
-match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
-match_wild_err_arm = "warn"
-match_wildcard_for_single_variants = "warn"
-maybe_infinite_iter = "warn"
-mismatching_type_param_order = "warn"
-missing_errors_doc = "warn"
-missing_fields_in_debug = "warn"
-missing_panics_doc = "warn"
-must_use_candidate = "allow" # Useful for audit but many false positives.
-mut_mut = "warn"
-naive_bytecount = "warn"
-needless_bitwise_bool = "warn"
-needless_continue = "warn"
-needless_for_each = "warn"
-needless_pass_by_value = "warn"
-needless_raw_string_hashes = "warn"
-no_effect_underscore_binding = "warn"
-no_mangle_with_rust_abi = "warn"
-option_as_ref_cloned = "warn"
-option_option = "warn"
-ptr_as_ptr = "warn"
-ptr_cast_constness = "warn"
-pub_underscore_fields = "warn"
-range_minus_one = "warn"
-range_plus_one = "warn"
-redundant_closure_for_method_calls = "warn"
-redundant_else = "warn"
-ref_as_ptr = "warn"
-ref_binding_to_reference = "warn"
-ref_option = "warn"
-ref_option_ref = "warn"
-return_self_not_must_use = "warn"
-same_functions_in_if_condition = "warn"
-semicolon_if_nothing_returned = "warn"
-should_panic_without_expect = "warn"
-similar_names = "allow" # Too many (subjectively) false positives.
-single_char_pattern = "warn"
-single_match_else = "warn"
-stable_sort_primitive = "warn"
-str_split_at_newline = "warn"
-string_add_assign = "warn"
-struct_excessive_bools = "warn"
-struct_field_names = "warn"
-too_many_lines = "warn"
-transmute_ptr_to_ptr = "warn"
-trivially_copy_pass_by_ref = "warn"
-unchecked_duration_subtraction = "warn"
-unicode_not_nfc = "warn"
-uninlined_format_args = "allow" # This is a subjective style choice.
-unnecessary_box_returns = "warn"
-unnecessary_join = "warn"
-unnecessary_literal_bound = "warn"
-unnecessary_wraps = "warn"
-unnested_or_patterns = "warn"
-unreadable_literal = "warn"
-unsafe_derive_deserialize = "warn"
-unused_async = "warn"
-unused_self = "warn"
-used_underscore_binding = "warn"
-used_underscore_items = "warn"
-verbose_bit_mask = "warn"
-wildcard_imports = "warn"
-zero_sized_map_values = "warn"
+[lints]
+workspace = true
diff --git a/units/README.md b/units/README.md
index aed33e6fc4..69db8748be 100644
--- a/units/README.md
+++ b/units/README.md
@@ -1,12 +1,3 @@
 # Bitcoin Units
 
 This crate provides basic Bitcoin numeric units such as `Amount`.
-
-## Minimum Supported Rust Version (MSRV)
-
-This library should always compile with any combination of features on **Rust 1.63.0**.
-
-## Licensing
-
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](../LICENSE).
-We use the [SPDX license list](https://spdx.org/licenses/) and [SPDX IDs](https://spdx.dev/ids/).
diff --git a/units/contrib/extra_lints.sh b/units/contrib/extra_lints.sh
new file mode 100755
index 0000000000..5e7f0c948d
--- /dev/null
+++ b/units/contrib/extra_lints.sh
@@ -0,0 +1,4 @@
+# No shebang, this file should not be executed.
+# shellcheck disable=SC2148
+
+cargo clippy --all-targets --no-default-features --keep-going -- -D warnings
diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index dd06db041d..0f9d4c1a20 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -60,6 +60,10 @@ impl From<InvalidCharacterError> for ParseError {
     fn from(e: InvalidCharacterError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
+impl From<BadPositionError> for ParseError {
+    fn from(e: BadPositionError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
+}
+
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.0 {
@@ -100,6 +104,8 @@ pub(crate) enum ParseAmountErrorInner {
     InputTooLarge(InputTooLargeError),
     /// Invalid character in input.
     InvalidCharacter(InvalidCharacterError),
+    /// A valid character is in an invalid position.
+    BadPosition(BadPositionError),
 }
 
 impl From<TooPreciseError> for ParseAmountError {
@@ -120,6 +126,10 @@ impl From<InvalidCharacterError> for ParseAmountError {
     }
 }
 
+impl From<BadPositionError> for ParseAmountError {
+    fn from(value: BadPositionError) -> Self { Self(ParseAmountErrorInner::BadPosition(value)) }
+}
+
 impl From<Infallible> for ParseAmountError {
     fn from(never: Infallible) -> Self { match never {} }
 }
@@ -137,8 +147,10 @@ impl fmt::Display for ParseAmountError {
             E::TooPrecise(ref error) => write_err!(f, "amount has a too high precision"; error),
             E::MissingDigits(ref error) => write_err!(f, "the input has too few digits"; error),
             E::InputTooLarge(ref error) => write_err!(f, "the input is too large"; error),
-            E::InvalidCharacter(ref error) =>
-                write_err!(f, "invalid character in the input"; error),
+            E::InvalidCharacter(ref error) => {
+                write_err!(f, "invalid character in the input"; error)
+            }
+            E::BadPosition(ref error) => write_err!(f, "valid character in bad position"; error),
         }
     }
 }
@@ -154,6 +166,7 @@ impl std::error::Error for ParseAmountError {
             E::OutOfRange(ref error) => Some(error),
             E::MissingDigits(ref error) => Some(error),
             E::InvalidCharacter(ref error) => Some(error),
+            E::BadPosition(ref error) => Some(error),
         }
     }
 }
@@ -217,9 +230,7 @@ impl fmt::Display for OutOfRangeError {
 impl std::error::Error for OutOfRangeError {}
 
 impl From<OutOfRangeError> for ParseAmountError {
-    fn from(value: OutOfRangeError) -> Self {
-        ParseAmountError(ParseAmountErrorInner::OutOfRange(value))
-    }
+    fn from(value: OutOfRangeError) -> Self { Self(ParseAmountErrorInner::OutOfRange(value)) }
 }
 
 /// Error returned when the input string has higher precision than satoshis.
@@ -321,6 +332,32 @@ impl fmt::Display for InvalidCharacterError {
 #[cfg(feature = "std")]
 impl std::error::Error for InvalidCharacterError {}
 
+/// Error returned when a valid character (e.g. '_') is in an invalid/bad position.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BadPositionError {
+    pub(super) char: char,
+    pub(super) position: usize,
+}
+
+impl fmt::Display for BadPositionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.char {
+            '_' => match self.position {
+                0 => f.write_str("the input amount is prefixed with an underscore (_)"),
+                // Position 1 can only occur when the amount begins with a minus (-), since an underscore
+                // at position 0 will cause an error with position 0, and this error marks the position of
+                // the second underscore.
+                1 => f.write_str("the input amount is prefixed with an underscore (_)"),
+                _ => f.write_str("there are consecutive underscores (_) in the input"),
+            },
+            c => write!(f, "The character '{}' is at a bad position: {}", c, self.position),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BadPositionError {}
+
 /// An error during amount parsing.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
@@ -337,11 +374,9 @@ impl From<Infallible> for ParseDenominationError {
 
 impl fmt::Display for ParseDenominationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseDenominationError as E;
-
         match *self {
-            E::Unknown(ref e) => write_err!(f, "denomination parse error"; e),
-            E::PossiblyConfusing(ref e) => write_err!(f, "denomination parse error"; e),
+            Self::Unknown(ref e) => write_err!(f, "denomination parse error"; e),
+            Self::PossiblyConfusing(ref e) => write_err!(f, "denomination parse error"; e),
         }
     }
 }
@@ -349,10 +384,8 @@ impl fmt::Display for ParseDenominationError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseDenominationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseDenominationError as E;
-
         match *self {
-            E::Unknown(_) | E::PossiblyConfusing(_) => None,
+            Self::Unknown(_) | Self::PossiblyConfusing(_) => None,
         }
     }
 }
@@ -393,3 +426,59 @@ impl fmt::Display for PossiblyConfusingDenominationError {
 impl std::error::Error for PossiblyConfusingDenominationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
+
+/// An error consensus decoding an `Amount`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AmountDecoderError(pub(super) AmountDecoderErrorInner);
+
+#[cfg(feature = "encoding")]
+impl AmountDecoderError {
+    /// Constructs an EOF error.
+    pub(super) fn eof(e: encoding::UnexpectedEofError) -> Self {
+        Self(AmountDecoderErrorInner::UnexpectedEof(e))
+    }
+
+    /// Constructs an out of range (`Amount::from_sat`) error.
+    pub(super) fn out_of_range(e: OutOfRangeError) -> Self {
+        Self(AmountDecoderErrorInner::OutOfRange(e))
+    }
+}
+
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) enum AmountDecoderErrorInner {
+    /// Not enough bytes given to decoder.
+    UnexpectedEof(encoding::UnexpectedEofError),
+    /// Decoded amount is too big.
+    OutOfRange(OutOfRangeError),
+}
+
+#[cfg(feature = "encoding")]
+impl From<Infallible> for AmountDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "encoding")]
+impl fmt::Display for AmountDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use AmountDecoderErrorInner as E;
+
+        match self.0 {
+            E::UnexpectedEof(ref e) => write_err!(f, "decode error"; e),
+            E::OutOfRange(ref e) => write_err!(f, "decode error"; e),
+        }
+    }
+}
+
+#[cfg(all(feature = "std", feature = "encoding"))]
+impl std::error::Error for AmountDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use AmountDecoderErrorInner as E;
+
+        match self.0 {
+            E::UnexpectedEof(ref e) => Some(e),
+            E::OutOfRange(ref e) => Some(e),
+        }
+    }
+}
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index b08e6ebb49..953196f5e5 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -5,7 +5,7 @@
 //! This module mainly introduces the [`Amount`] and [`SignedAmount`] types.
 //! We refer to the documentation on the types for more information.
 
-mod error;
+pub mod error;
 mod result;
 #[cfg(feature = "serde")]
 pub mod serde;
@@ -25,19 +25,26 @@ use core::str::FromStr;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
-use self::error::{MissingDigitsKind, ParseAmountErrorInner, ParseErrorInner};
+use self::error::{
+    BadPositionError, InputTooLargeError, InvalidCharacterError, MissingDenominationError,
+    MissingDigitsError, MissingDigitsKind, ParseAmountErrorInner, ParseErrorInner,
+    PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
+};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
-    error::{
-        InputTooLargeError, InvalidCharacterError, MissingDenominationError, MissingDigitsError,
-        OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
-        PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
-    },
     signed::SignedAmount,
     unsigned::Amount,
 };
+#[cfg(feature = "encoding")]
+#[doc(no_inline)]
+pub use self::error::AmountDecoderError;
+#[doc(no_inline)]
+pub use self::error::{OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError};
+#[doc(inline)]
+#[cfg(feature = "encoding")]
+pub use self::unsigned::{AmountDecoder, AmountEncoder};
 
 /// A set of denominations in which amounts can be expressed.
 ///
@@ -99,53 +106,53 @@ pub enum Denomination {
 
 impl Denomination {
     /// Convenience alias for `Denomination::Bitcoin`.
-    pub const BTC: Self = Denomination::Bitcoin;
+    pub const BTC: Self = Self::Bitcoin;
 
     /// Convenience alias for `Denomination::Satoshi`.
-    pub const SAT: Self = Denomination::Satoshi;
+    pub const SAT: Self = Self::Satoshi;
 
     /// The number of decimal places more than a satoshi.
     fn precision(self) -> i8 {
         match self {
-            Denomination::Bitcoin => -8,
-            Denomination::CentiBitcoin => -6,
-            Denomination::MilliBitcoin => -5,
-            Denomination::MicroBitcoin => -2,
-            Denomination::Bit => -2,
-            Denomination::Satoshi => 0,
-            Denomination::_DoNotUse(infallible) => match infallible {},
+            Self::Bitcoin => -8,
+            Self::CentiBitcoin => -6,
+            Self::MilliBitcoin => -5,
+            Self::MicroBitcoin => -2,
+            Self::Bit => -2,
+            Self::Satoshi => 0,
+            Self::_DoNotUse(infallible) => match infallible {},
         }
     }
 
     /// Returns a string representation of this denomination.
     fn as_str(self) -> &'static str {
         match self {
-            Denomination::Bitcoin => "BTC",
-            Denomination::CentiBitcoin => "cBTC",
-            Denomination::MilliBitcoin => "mBTC",
-            Denomination::MicroBitcoin => "uBTC",
-            Denomination::Bit => "bits",
-            Denomination::Satoshi => "satoshi",
-            Denomination::_DoNotUse(infallible) => match infallible {},
+            Self::Bitcoin => "BTC",
+            Self::CentiBitcoin => "cBTC",
+            Self::MilliBitcoin => "mBTC",
+            Self::MicroBitcoin => "uBTC",
+            Self::Bit => "bits",
+            Self::Satoshi => "satoshi",
+            Self::_DoNotUse(infallible) => match infallible {},
         }
     }
 
     /// The different `str` forms of denominations that are recognized.
     fn forms(s: &str) -> Option<Self> {
         match s {
-            "BTC" | "btc" => Some(Denomination::Bitcoin),
-            "cBTC" | "cbtc" => Some(Denomination::CentiBitcoin),
-            "mBTC" | "mbtc" => Some(Denomination::MilliBitcoin),
-            "uBTC" | "ubtc" | "µBTC" | "µbtc" => Some(Denomination::MicroBitcoin),
-            "bit" | "bits" | "BIT" | "BITS" => Some(Denomination::Bit),
+            "BTC" | "btc" => Some(Self::Bitcoin),
+            "cBTC" | "cbtc" => Some(Self::CentiBitcoin),
+            "mBTC" | "mbtc" => Some(Self::MilliBitcoin),
+            "uBTC" | "ubtc" | "µBTC" | "µbtc" => Some(Self::MicroBitcoin),
+            "bit" | "bits" | "BIT" | "BITS" => Some(Self::Bit),
             "SATOSHI" | "satoshi" | "SATOSHIS" | "satoshis" | "SAT" | "sat" | "SATS" | "sats" =>
-                Some(Denomination::Satoshi),
+                Some(Self::Satoshi),
             _ => None,
         }
     }
 }
 
-/// These form are ambiguous and could have many meanings.  For example, M could denote Mega or Milli.
+/// These forms are ambiguous and could have many meanings.  For example, M could denote Mega or Milli.
 /// If any of these forms are used, an error type `PossiblyConfusingDenomination` is returned.
 const CONFUSING_FORMS: [&str; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 
@@ -170,7 +177,7 @@ impl FromStr for Denomination {
             return Err(E::PossiblyConfusing(PossiblyConfusingDenominationError(s.into())));
         };
 
-        let form = self::Denomination::forms(s);
+        let form = Self::forms(s);
 
         form.ok_or_else(|| E::Unknown(UnknownDenominationError(s.into())))
     }
@@ -202,6 +209,7 @@ const INPUT_STRING_LEN_LIMIT: usize = 50;
 /// [`bool`] indicator for a negative amount.
 ///
 /// The `bool` is only needed to distinguish -0 from 0.
+#[allow(clippy::too_many_lines)]
 fn parse_signed_to_satoshi(
     mut s: &str,
     denom: Denomination,
@@ -252,6 +260,8 @@ fn parse_signed_to_satoshi(
     };
 
     let mut decimals = None;
+    // The number of consecutive underscores
+    let mut underscores = None;
     let mut value: i64 = 0; // as satoshis
     for (i, c) in s.char_indices() {
         match c {
@@ -273,10 +283,29 @@ fn parse_signed_to_satoshi(
                             position: i + usize::from(is_negative),
                         })),
                 };
+                underscores = None;
             }
+            '_' if i == 0 =>
+            // Leading underscore
+                return Err(InnerParseError::BadPosition(BadPositionError {
+                    char: '_',
+                    position: i + usize::from(is_negative),
+                })),
+            '_' => match underscores {
+                None => underscores = Some(1),
+                // Consecutive underscores
+                _ =>
+                    return Err(InnerParseError::BadPosition(BadPositionError {
+                        char: '_',
+                        position: i + usize::from(is_negative),
+                    })),
+            },
             '.' => match decimals {
                 None if max_decimals <= 0 => break,
-                None => decimals = Some(0),
+                None => {
+                    decimals = Some(0);
+                    underscores = None;
+                }
                 // Double decimal dot.
                 _ =>
                     return Err(InnerParseError::InvalidCharacter(InvalidCharacterError {
@@ -316,6 +345,7 @@ enum InnerParseError {
     MissingDigits(MissingDigitsError),
     InputTooLarge(usize),
     InvalidCharacter(InvalidCharacterError),
+    BadPosition(BadPositionError),
 }
 
 impl From<Infallible> for InnerParseError {
@@ -333,6 +363,7 @@ impl InnerParseError {
                 ParseAmountError(ParseAmountErrorInner::InputTooLarge(InputTooLargeError { len })),
             Self::InvalidCharacter(e) =>
                 ParseAmountError(ParseAmountErrorInner::InvalidCharacter(e)),
+            Self::BadPosition(e) => ParseAmountError(ParseAmountErrorInner::BadPosition(e)),
         }
     }
 }
@@ -362,7 +393,7 @@ struct FormatOptions {
 
 impl FormatOptions {
     fn from_formatter(f: &fmt::Formatter) -> Self {
-        FormatOptions {
+        Self {
             fill: f.fill(),
             align: f.align(),
             width: f.width(),
@@ -375,7 +406,7 @@ impl FormatOptions {
 
 impl Default for FormatOptions {
     fn default() -> Self {
-        FormatOptions {
+        Self {
             fill: ' ',
             align: None,
             width: None,
@@ -405,7 +436,7 @@ fn repeat_char(f: &mut dyn fmt::Write, c: char, count: usize) -> fmt::Result {
     Ok(())
 }
 
-/// Format the given satoshi amount in the given denomination.
+/// Formats the given satoshi amount in the given denomination.
 fn fmt_satoshi_in(
     mut satoshi: u64,
     negative: bool,
@@ -492,7 +523,7 @@ fn fmt_satoshi_in(
         (true, false, fmt::Alignment::Left) => (0, width - num_width),
         // If the required padding is odd it needs to be skewed to the left
         (true, false, fmt::Alignment::Center) =>
-            ((width - num_width) / 2, (width - num_width + 1) / 2),
+            ((width - num_width) / 2, (width - num_width).div_ceil(2)),
     };
 
     if !options.sign_aware_zero_pad {
@@ -593,50 +624,17 @@ enum DisplayStyle {
     DynamicDenomination,
 }
 
-/// Calculates the sum over the iterator using checked arithmetic.
-pub trait CheckedSum<R>: sealed::Sealed<R> {
-    /// Calculates the sum over the iterator using checked arithmetic. If an
-    /// overflow happens it returns [`None`].
-    fn checked_sum(self) -> Option<R>;
-}
-
-impl<T> CheckedSum<Amount> for T
-where
-    T: Iterator<Item = Amount>,
-{
-    fn checked_sum(mut self) -> Option<Amount> { self.try_fold(Amount::ZERO, Amount::checked_add) }
-}
-
-impl<T> CheckedSum<SignedAmount> for T
-where
-    T: Iterator<Item = SignedAmount>,
-{
-    fn checked_sum(mut self) -> Option<SignedAmount> {
-        self.try_fold(SignedAmount::ZERO, SignedAmount::checked_add)
-    }
-}
-
-mod sealed {
-    use super::{Amount, SignedAmount};
-
-    /// Used to seal the `CheckedSum` trait
-    pub trait Sealed<A> {}
-
-    impl<T> Sealed<Amount> for T where T: Iterator<Item = Amount> {}
-    impl<T> Sealed<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
-}
-
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Denomination {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=5)?;
         match choice {
-            0 => Ok(Denomination::Bitcoin),
-            1 => Ok(Denomination::CentiBitcoin),
-            2 => Ok(Denomination::MilliBitcoin),
-            3 => Ok(Denomination::MicroBitcoin),
-            4 => Ok(Denomination::Bit),
-            _ => Ok(Denomination::Satoshi),
+            0 => Ok(Self::Bitcoin),
+            1 => Ok(Self::CentiBitcoin),
+            2 => Ok(Self::MilliBitcoin),
+            3 => Ok(Self::MicroBitcoin),
+            4 => Ok(Self::Bit),
+            _ => Ok(Self::Satoshi),
         }
     }
 }
diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 1c81872f45..55135a8072 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -8,8 +8,10 @@ use core::ops;
 use NumOpResult as R;
 
 use super::{Amount, SignedAmount};
-use crate::internal_macros::{impl_div_assign, impl_mul_assign};
-use crate::{MathOp, NumOpError, NumOpResult, OptionExt};
+use crate::internal_macros::{
+    impl_add_assign_for_results, impl_div_assign, impl_mul_assign, impl_sub_assign_for_results,
+};
+use crate::result::{MathOp, NumOpError, NumOpResult, OptionExt};
 
 impl From<Amount> for NumOpResult<Amount> {
     fn from(a: Amount) -> Self { Self::Valid(a) }
@@ -187,57 +189,6 @@ crate::internal_macros::impl_op_for_references! {
 
         fn rem(self, modulus: i64) -> Self::Output { self.and_then(|lhs| lhs % modulus) }
     }
-
-    impl<T> ops::Add<NumOpResult<T>> for NumOpResult<T>
-    where
-        (T: Copy + ops::Add<Output = NumOpResult<T>>)
-    {
-        type Output = NumOpResult<T>;
-
-        fn add(self, rhs: Self) -> Self::Output {
-            match (self, rhs) {
-                (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-                (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
-            }
-        }
-    }
-
-    impl<T> ops::Add<T> for NumOpResult<T>
-    where
-        (T: Copy + ops::Add<NumOpResult<T>, Output = NumOpResult<T>>)
-    {
-        type Output = NumOpResult<T>;
-
-        fn add(self, rhs: T) -> Self::Output { rhs + self }
-    }
-
-    impl<T> ops::Sub<NumOpResult<T>> for NumOpResult<T>
-    where
-        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
-    {
-        type Output = NumOpResult<T>;
-
-        fn sub(self, rhs: Self) -> Self::Output {
-            match (self, rhs) {
-                (R::Valid(lhs), R::Valid(rhs)) => lhs - rhs,
-                (_, _) => R::Error(NumOpError::while_doing(MathOp::Sub)),
-            }
-        }
-    }
-
-    impl<T> ops::Sub<T> for NumOpResult<T>
-    where
-        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
-    {
-        type Output = NumOpResult<T>;
-
-        fn sub(self, rhs: T) -> Self::Output {
-            match self {
-                R::Valid(amount) => amount - rhs,
-                R::Error(_) => self,
-            }
-        }
-    }
 }
 
 impl_mul_assign!(NumOpResult<Amount>, u64);
@@ -245,6 +196,11 @@ impl_mul_assign!(NumOpResult<SignedAmount>, i64);
 impl_div_assign!(NumOpResult<Amount>, u64);
 impl_div_assign!(NumOpResult<SignedAmount>, i64);
 
+impl_add_assign_for_results!(Amount);
+impl_add_assign_for_results!(SignedAmount);
+impl_sub_assign_for_results!(Amount);
+impl_sub_assign_for_results!(SignedAmount);
+
 impl ops::Neg for SignedAmount {
     type Output = Self;
 
@@ -253,48 +209,187 @@ impl ops::Neg for SignedAmount {
     }
 }
 
-impl core::iter::Sum<NumOpResult<Amount>> for NumOpResult<Amount> {
+impl core::iter::Sum<Self> for NumOpResult<Amount> {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = NumOpResult<Amount>>,
+        I: Iterator<Item = Self>,
     {
-        iter.fold(R::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-            (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
+        iter.fold(Self::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
+            (Self::Valid(lhs), Self::Valid(rhs)) => lhs + rhs,
+            (_, _) => Self::Error(NumOpError::while_doing(MathOp::Add)),
         })
     }
 }
-impl<'a> core::iter::Sum<&'a NumOpResult<Amount>> for NumOpResult<Amount> {
+impl<'a> core::iter::Sum<&'a Self> for NumOpResult<Amount> {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a NumOpResult<Amount>>,
+        I: Iterator<Item = &'a Self>,
     {
-        iter.fold(R::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-            (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
+        iter.fold(Self::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
+            (Self::Valid(lhs), Self::Valid(rhs)) => lhs + rhs,
+            (_, _) => Self::Error(NumOpError::while_doing(MathOp::Add)),
         })
     }
 }
 
-impl core::iter::Sum<NumOpResult<SignedAmount>> for NumOpResult<SignedAmount> {
+impl core::iter::Sum<Self> for NumOpResult<SignedAmount> {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = NumOpResult<SignedAmount>>,
+        I: Iterator<Item = Self>,
     {
-        iter.fold(R::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-            (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
+        iter.fold(Self::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
+            (Self::Valid(lhs), Self::Valid(rhs)) => lhs + rhs,
+            (_, _) => Self::Error(NumOpError::while_doing(MathOp::Add)),
         })
     }
 }
-impl<'a> core::iter::Sum<&'a NumOpResult<SignedAmount>> for NumOpResult<SignedAmount> {
+impl<'a> core::iter::Sum<&'a Self> for NumOpResult<SignedAmount> {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a NumOpResult<SignedAmount>>,
+        I: Iterator<Item = &'a Self>,
     {
-        iter.fold(R::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-            (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
+        iter.fold(Self::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
+            (Self::Valid(lhs), Self::Valid(rhs)) => lhs + rhs,
+            (_, _) => Self::Error(NumOpError::while_doing(MathOp::Add)),
         })
     }
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sum_amount_results() {
+        let amounts = [
+            NumOpResult::Valid(Amount::from_sat_u32(100)),
+            NumOpResult::Valid(Amount::from_sat_u32(200)),
+            NumOpResult::Valid(Amount::from_sat_u32(300)),
+        ];
+
+        let sum: NumOpResult<Amount> = amounts.into_iter().sum();
+        assert_eq!(sum, NumOpResult::Valid(Amount::from_sat_u32(600)));
+    }
+
+    #[test]
+    fn test_sum_amount_results_with_references() {
+        let amounts = [
+            NumOpResult::Valid(Amount::from_sat_u32(100)),
+            NumOpResult::Valid(Amount::from_sat_u32(200)),
+            NumOpResult::Valid(Amount::from_sat_u32(300)),
+        ];
+
+        let sum: NumOpResult<Amount> = amounts.iter().sum();
+        assert_eq!(sum, NumOpResult::Valid(Amount::from_sat_u32(600)));
+    }
+
+    #[test]
+    fn test_sum_amount_with_error_propagation() {
+        let amounts = [
+            NumOpResult::Valid(Amount::from_sat_u32(100)),
+            NumOpResult::Error(NumOpError::while_doing(MathOp::Add)),
+            NumOpResult::Valid(Amount::from_sat_u32(200)),
+        ];
+
+        let sum: NumOpResult<Amount> = amounts.into_iter().sum();
+        assert!(matches!(sum, NumOpResult::Error(_)));
+    }
+
+    #[test]
+    fn test_sum_signed_amount_results() {
+        let amounts = [
+            NumOpResult::Valid(SignedAmount::from_sat_i32(100)),
+            NumOpResult::Valid(SignedAmount::from_sat_i32(-50)),
+            NumOpResult::Valid(SignedAmount::from_sat_i32(200)),
+        ];
+
+        let sum: NumOpResult<SignedAmount> = amounts.into_iter().sum();
+        assert_eq!(sum, NumOpResult::Valid(SignedAmount::from_sat_i32(250)));
+    }
+
+    #[test]
+    fn test_sum_signed_amount_results_with_references() {
+        let amounts = [
+            NumOpResult::Valid(SignedAmount::from_sat_i32(100)),
+            NumOpResult::Valid(SignedAmount::from_sat_i32(-50)),
+            NumOpResult::Valid(SignedAmount::from_sat_i32(200)),
+        ];
+
+        let sum: NumOpResult<SignedAmount> = amounts.iter().sum();
+        assert_eq!(sum, NumOpResult::Valid(SignedAmount::from_sat_i32(250)));
+    }
+
+    #[test]
+    fn test_sum_signed_amount_with_error_propagation() {
+        let amounts = [
+            NumOpResult::Valid(SignedAmount::from_sat_i32(100)),
+            NumOpResult::Error(NumOpError::while_doing(MathOp::Add)),
+            NumOpResult::Valid(SignedAmount::from_sat_i32(200)),
+        ];
+
+        let sum: NumOpResult<SignedAmount> = amounts.into_iter().sum();
+        assert!(matches!(sum, NumOpResult::Error(_)));
+    }
+
+    #[test]
+    fn test_op_assign_amount() {
+        let sat = Amount::from_sat_u32(50);
+
+        let mut res = sat + sat;
+        res += Amount::from_sat_u32(50);
+        assert_eq!(res, NumOpResult::Valid(Amount::from_sat_u32(150)));
+
+        let add_err = NumOpResult::Error(NumOpError::while_doing(MathOp::Add));
+        res += add_err; // Add an error result
+        assert_eq!(res, add_err);
+
+        let mut res = sat + sat;
+        res -= Amount::from_sat_u32(20);
+        assert_eq!(res, NumOpResult::Valid(Amount::from_sat_u32(80)));
+
+        let sub_err = NumOpResult::Error(NumOpError::while_doing(MathOp::Sub));
+        res -= sub_err; // Subtract an error result
+        assert_eq!(res, sub_err);
+    }
+
+    #[test]
+    fn test_op_assign_signed_amount() {
+        let ssat = SignedAmount::from_sat_i32(50);
+
+        let mut res = ssat + ssat;
+        res += SignedAmount::from_sat_i32(-30);
+        assert_eq!(res, NumOpResult::Valid(SignedAmount::from_sat_i32(70)));
+
+        let add_err = NumOpResult::Error(NumOpError::while_doing(MathOp::Add));
+        res += add_err; // Add an error result
+        assert_eq!(res, add_err);
+
+        let mut res = ssat + ssat;
+        res -= SignedAmount::from_sat_i32(25);
+        assert_eq!(res, NumOpResult::Valid(SignedAmount::from_sat_i32(75)));
+
+        let sub_err = NumOpResult::Error(NumOpError::while_doing(MathOp::Sub));
+        res -= sub_err; // Subtract an error result
+        assert_eq!(res, sub_err);
+    }
+
+    #[test]
+    fn test_op_assign_amount_error() {
+        let mut res: NumOpResult<Amount> = NumOpResult::Error(NumOpError::while_doing(MathOp::Add));
+
+        // Adding a valid amount to an error should make an Add error
+        res += Amount::from_sat_u32(10);
+        assert_eq!(res, NumOpResult::Error(NumOpError::while_doing(MathOp::Add)));
+
+        // Adding an error to an error change to an Add error
+        res += NumOpResult::Error(NumOpError::while_doing(MathOp::Sub));
+        assert_eq!(res, NumOpResult::Error(NumOpError::while_doing(MathOp::Add)));
+
+        // Subtracting a valid amount from an error should make a Sub error
+        res -= Amount::from_sat_u32(10);
+        assert_eq!(res, NumOpResult::Error(NumOpError::while_doing(MathOp::Sub)));
+
+        // Subtracting an error from an error change to a Sub error
+        res -= NumOpResult::Error(NumOpError::while_doing(MathOp::Add));
+        assert_eq!(res, NumOpResult::Error(NumOpError::while_doing(MathOp::Sub)));
+    }
+}
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 4be7660581..cdb952da30 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -25,43 +25,8 @@
 #[cfg(feature = "alloc")]
 use core::fmt;
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-#[cfg(feature = "alloc")] // This is because `to_float_in` uses `to_string`.
-use super::Denomination;
 #[cfg(feature = "alloc")]
 use super::ParseAmountError;
-use super::{Amount, SignedAmount};
-
-/// This trait is used only to avoid code duplication and naming collisions
-/// of the different serde serialization crates.
-pub trait SerdeAmount: Copy + Sized {
-    fn ser_sat<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-    fn des_sat<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error>;
-    #[cfg(feature = "alloc")]
-    fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-    #[cfg(feature = "alloc")]
-    fn des_btc<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error>;
-    #[cfg(feature = "alloc")]
-    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-    #[cfg(feature = "alloc")]
-    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error>;
-}
-
-mod private {
-    /// Controls access to the trait methods.
-    pub struct Token;
-}
-
-/// This trait is only for internal Amount type serialization/deserialization
-pub trait SerdeAmountForOpt: Copy + Sized + SerdeAmount {
-    fn type_prefix(_: private::Token) -> &'static str;
-    fn ser_sat_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-    #[cfg(feature = "alloc")]
-    fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-    #[cfg(feature = "alloc")]
-    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
-}
 
 #[cfg(feature = "alloc")]
 struct DisplayFullError(ParseAmountError);
@@ -87,119 +52,41 @@ impl fmt::Display for DisplayFullError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
-impl SerdeAmount for Amount {
-    fn ser_sat<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        u64::serialize(&self.to_sat(), s)
-    }
-    fn des_sat<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        Amount::from_sat(u64::deserialize(d)?).map_err(D::Error::custom)
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        f64::serialize(&self.to_float_in(Denomination::Bitcoin), s)
-    }
-    #[cfg(feature = "alloc")]
-    fn des_btc<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        Amount::from_btc(f64::deserialize(d)?).map_err(DisplayFullError).map_err(D::Error::custom)
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_str(&self.to_string_in(Denomination::Bitcoin))
-    }
-    #[cfg(feature = "alloc")]
-    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        let s: alloc::string::String = Deserialize::deserialize(d)?;
-        Amount::from_str_in(&s, Denomination::Bitcoin)
-            .map_err(DisplayFullError)
-            .map_err(D::Error::custom)
-    }
-}
-
-impl SerdeAmountForOpt for Amount {
-    fn type_prefix(_: private::Token) -> &'static str { "u" }
-    fn ser_sat_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_sat())
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_btc())
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_string_in(Denomination::Bitcoin))
-    }
-}
-
-impl SerdeAmount for SignedAmount {
-    fn ser_sat<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        i64::serialize(&self.to_sat(), s)
-    }
-    fn des_sat<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        SignedAmount::from_sat(i64::deserialize(d)?).map_err(D::Error::custom)
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        f64::serialize(&self.to_float_in(Denomination::Bitcoin), s)
-    }
-    #[cfg(feature = "alloc")]
-    fn des_btc<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        SignedAmount::from_btc(f64::deserialize(d)?)
-            .map_err(DisplayFullError)
-            .map_err(D::Error::custom)
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_str(self.to_string_in(Denomination::Bitcoin).as_str())
-    }
-    #[cfg(feature = "alloc")]
-    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        use serde::de::Error;
-        let s: alloc::string::String = Deserialize::deserialize(d)?;
-        SignedAmount::from_str_in(&s, Denomination::Bitcoin)
-            .map_err(DisplayFullError)
-            .map_err(D::Error::custom)
-    }
-}
-
-impl SerdeAmountForOpt for SignedAmount {
-    fn type_prefix(_: private::Token) -> &'static str { "i" }
-    fn ser_sat_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_sat())
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_btc())
-    }
-    #[cfg(feature = "alloc")]
-    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
-        s.serialize_some(&self.to_string_in(Denomination::Bitcoin))
-    }
-}
-
 pub mod as_sat {
-    //! Serialize and deserialize [`Amount`](crate::Amount) as real numbers denominated in satoshi.
+    //! Serialize and deserialize [`Amount`] and [`SignedAmount`] as real numbers denominated in satoshi.
+    //!
     //! Use with `#[serde(with = "amount::serde::as_sat")]`.
+    //!
+    //! [`Amount`]: crate::Amount
+    //! [`SignedAmount`]: crate::SignedAmount
 
-    use serde::{Deserializer, Serializer};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    use super::private;
-    use crate::amount::serde::SerdeAmount;
+    use crate::SignedAmount;
 
-    pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
-        a.ser_sat(s, private::Token)
+    pub fn serialize<A, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error>
+    where
+        A: Into<SignedAmount> + Copy,
+    {
+        let amount: SignedAmount = (*a).into();
+        i64::serialize(&amount.to_sat(), s)
     }
 
-    pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
-        A::des_sat(d, private::Token)
+    pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<A, D::Error>
+    where
+        A: TryFrom<SignedAmount>,
+        <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+    {
+        let sat = i64::deserialize(d)?;
+        let amount = SignedAmount::from_sat(sat).map_err(serde::de::Error::custom)?;
+
+        A::try_from(amount).map_err(serde::de::Error::custom)
     }
 
     pub mod opt {
-        //! Serialize and deserialize [`Option<Amount>`](crate::Amount) as real numbers denominated in satoshi.
+        //! Serialize and deserialize `Option<Amount>` and `Option<SignedAmount>` as real numbers
+        //! denominated in satoshi.
+        //!
         //! Use with `#[serde(default, with = "amount::serde::as_sat::opt")]`.
 
         use core::fmt;
@@ -207,30 +94,38 @@ pub mod as_sat {
 
         use serde::{de, Deserializer, Serializer};
 
-        use super::private;
-        use crate::amount::serde::SerdeAmountForOpt;
+        use crate::SignedAmount;
 
         #[allow(clippy::ref_option)] // API forced by serde.
-        pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
-            a: &Option<A>,
-            s: S,
-        ) -> Result<S::Ok, S::Error> {
+        pub fn serialize<A, S: Serializer>(a: &Option<A>, s: S) -> Result<S::Ok, S::Error>
+        where
+            A: Into<SignedAmount> + Copy,
+        {
             match *a {
-                Some(a) => a.ser_sat_opt(s, private::Token),
+                Some(a) => {
+                    let amount: SignedAmount = a.into();
+                    s.serialize_some(&amount.to_sat())
+                }
                 None => s.serialize_none(),
             }
         }
 
-        pub fn deserialize<'d, A: SerdeAmountForOpt, D: Deserializer<'d>>(
-            d: D,
-        ) -> Result<Option<A>, D::Error> {
+        pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<Option<A>, D::Error>
+        where
+            A: TryFrom<SignedAmount>,
+            <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+        {
             struct VisitOptAmt<X>(PhantomData<X>);
 
-            impl<'de, X: SerdeAmountForOpt> de::Visitor<'de> for VisitOptAmt<X> {
+            impl<'de, X> de::Visitor<'de> for VisitOptAmt<X>
+            where
+                X: TryFrom<SignedAmount>,
+                <X as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+            {
                 type Value = Option<X>;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    write!(formatter, "an Option<{}64>", X::type_prefix(private::Token))
+                    write!(formatter, "an Option<i64>")
                 }
 
                 fn visit_none<E>(self) -> Result<Self::Value, E>
@@ -239,11 +134,12 @@ pub mod as_sat {
                 {
                     Ok(None)
                 }
+
                 fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
                 where
                     D: Deserializer<'de>,
                 {
-                    Ok(Some(X::des_sat(d, private::Token)?))
+                    Ok(Some(super::deserialize(d)?))
                 }
             }
             d.deserialize_option(VisitOptAmt::<A>(PhantomData))
@@ -253,51 +149,78 @@ pub mod as_sat {
 
 #[cfg(feature = "alloc")]
 pub mod as_btc {
-    //! Serialize and deserialize [`Amount`](crate::Amount) as JSON numbers denominated in BTC.
+    //! Serialize and deserialize [`Amount`] and [`SignedAmount`] as JSON numbers denominated in BTC.
+    //!
     //! Use with `#[serde(with = "amount::serde::as_btc")]`.
+    //!
+    //! [`Amount`]: crate::Amount
+    //! [`SignedAmount`]: crate::SignedAmount
+
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use super::DisplayFullError;
+    use crate::amount::{Denomination, SignedAmount};
+
+    pub fn serialize<A, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error>
+    where
+        A: Into<SignedAmount> + Copy,
+    {
+        let amount: SignedAmount = (*a).into();
+        f64::serialize(&amount.to_float_in(Denomination::Bitcoin), s)
+    }
+
+    pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<A, D::Error>
+    where
+        A: TryFrom<SignedAmount>,
+        <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+    {
+        let btc = f64::deserialize(d)?;
+        let amount = SignedAmount::from_btc(btc)
+            .map_err(DisplayFullError)
+            .map_err(serde::de::Error::custom)?;
 
-    use serde::{Deserializer, Serializer};
-
-    use super::private;
-    use crate::amount::serde::SerdeAmount;
-
-    pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
-        a.ser_btc(s, private::Token)
-    }
-
-    pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
-        A::des_btc(d, private::Token)
+        A::try_from(amount).map_err(serde::de::Error::custom)
     }
 
     pub mod opt {
-        //! Serialize and deserialize `Option<Amount>` as JSON numbers denominated in BTC.
+        //! Serialize and deserialize `Option<Amount>` and `Option<SignedAmount>` as JSON numbers
+        //! denominated in BTC.
+        //!
         //! Use with `#[serde(default, with = "amount::serde::as_btc::opt")]`.
 
         use core::fmt;
         use core::marker::PhantomData;
 
-        use serde::{de, Deserializer, Serializer};
+        use serde::{de, Deserializer, Serialize, Serializer};
 
-        use super::private;
-        use crate::amount::serde::SerdeAmountForOpt;
+        use crate::amount::{Denomination, SignedAmount};
 
         #[allow(clippy::ref_option)] // API forced by serde.
-        pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
-            a: &Option<A>,
-            s: S,
-        ) -> Result<S::Ok, S::Error> {
+        pub fn serialize<A, S: Serializer>(a: &Option<A>, s: S) -> Result<S::Ok, S::Error>
+        where
+            A: Into<SignedAmount> + Copy,
+        {
             match *a {
-                Some(a) => a.ser_btc_opt(s, private::Token),
+                Some(a) => {
+                    let amount: SignedAmount = a.into();
+                    f64::serialize(&amount.to_float_in(Denomination::Bitcoin), s)
+                }
                 None => s.serialize_none(),
             }
         }
 
-        pub fn deserialize<'d, A: SerdeAmountForOpt, D: Deserializer<'d>>(
-            d: D,
-        ) -> Result<Option<A>, D::Error> {
+        pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<Option<A>, D::Error>
+        where
+            A: TryFrom<SignedAmount>,
+            <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+        {
             struct VisitOptAmt<X>(PhantomData<X>);
 
-            impl<'de, X: SerdeAmountForOpt> de::Visitor<'de> for VisitOptAmt<X> {
+            impl<'de, X> de::Visitor<'de> for VisitOptAmt<X>
+            where
+                X: TryFrom<SignedAmount>,
+                <X as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+            {
                 type Value = Option<X>;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -310,11 +233,12 @@ pub mod as_btc {
                 {
                     Ok(None)
                 }
+
                 fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
                 where
                     D: Deserializer<'de>,
                 {
-                    Ok(Some(X::des_btc(d, private::Token)?))
+                    Ok(Some(super::deserialize(d)?))
                 }
             }
             d.deserialize_option(VisitOptAmt::<A>(PhantomData))
@@ -324,51 +248,80 @@ pub mod as_btc {
 
 #[cfg(feature = "alloc")]
 pub mod as_str {
-    //! Serialize and deserialize [`Amount`](crate::Amount) as a JSON string denominated in BTC.
+    //! Serialize and deserialize [`Amount`] and [`SignedAmount`] as a JSON string denominated in BTC.
+    //!
     //! Use with `#[serde(with = "amount::serde::as_str")]`.
+    //!
+    //! [`Amount`]: crate::Amount
+    //! [`SignedAmount`]: crate::SignedAmount
+
+    use alloc::string::String;
 
-    use serde::{Deserializer, Serializer};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    use super::private;
-    use crate::amount::serde::SerdeAmount;
+    use super::DisplayFullError;
+    use crate::amount::{Denomination, SignedAmount};
 
-    pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
-        a.ser_str(s, private::Token)
+    pub fn serialize<A, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error>
+    where
+        A: Into<SignedAmount> + Copy,
+    {
+        let amount: SignedAmount = (*a).into();
+        str::serialize(&amount.to_string_in(Denomination::Bitcoin), s)
     }
 
-    pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
-        A::des_str(d, private::Token)
+    pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<A, D::Error>
+    where
+        A: TryFrom<SignedAmount>,
+        <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+    {
+        let btc = String::deserialize(d)?;
+        let amount = SignedAmount::from_str_in(&btc, Denomination::Bitcoin)
+            .map_err(DisplayFullError)
+            .map_err(serde::de::Error::custom)?;
+
+        A::try_from(amount).map_err(serde::de::Error::custom)
     }
 
     pub mod opt {
-        //! Serialize and deserialize `Option<Amount>` as a JSON string denominated in BTC.
+        //! Serialize and deserialize `Option<Amount>` and `Option<SignedAmount>` as a JSON string
+        //! denominated in BTC.
+        //!
         //! Use with `#[serde(default, with = "amount::serde::as_str::opt")]`.
 
         use core::fmt;
         use core::marker::PhantomData;
 
-        use serde::{de, Deserializer, Serializer};
+        use serde::{de, Deserializer, Serialize, Serializer};
 
-        use super::private;
-        use crate::amount::serde::SerdeAmountForOpt;
+        use crate::amount::{Denomination, SignedAmount};
 
         #[allow(clippy::ref_option)] // API forced by serde.
-        pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
-            a: &Option<A>,
-            s: S,
-        ) -> Result<S::Ok, S::Error> {
+        pub fn serialize<A, S: Serializer>(a: &Option<A>, s: S) -> Result<S::Ok, S::Error>
+        where
+            A: Into<SignedAmount> + Copy,
+        {
             match *a {
-                Some(a) => a.ser_str_opt(s, private::Token),
+                Some(a) => {
+                    let amount: SignedAmount = a.into();
+                    str::serialize(&amount.to_string_in(Denomination::Bitcoin), s)
+                }
                 None => s.serialize_none(),
             }
         }
 
-        pub fn deserialize<'d, A: SerdeAmountForOpt, D: Deserializer<'d>>(
-            d: D,
-        ) -> Result<Option<A>, D::Error> {
+        pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<Option<A>, D::Error>
+        where
+            A: TryFrom<SignedAmount>,
+            <A as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+        {
             struct VisitOptAmt<X>(PhantomData<X>);
 
-            impl<'de, X: SerdeAmountForOpt> de::Visitor<'de> for VisitOptAmt<X> {
+            impl<'de, X> de::Visitor<'de> for VisitOptAmt<X>
+            where
+                X: TryFrom<SignedAmount>,
+                <X as TryFrom<SignedAmount>>::Error: core::fmt::Display,
+            {
                 type Value = Option<X>;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -381,11 +334,12 @@ pub mod as_str {
                 {
                     Ok(None)
                 }
+
                 fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
                 where
                     D: Deserializer<'de>,
                 {
-                    Ok(Some(X::des_str(d, private::Token)?))
+                    Ok(Some(super::deserialize(d)?))
                 }
             }
             d.deserialize_option(VisitOptAmt::<A>(PhantomData))
@@ -395,14 +349,10 @@ pub mod as_str {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::amount;
 
-    #[test]
-    fn sanity_check() {
-        assert_eq!(Amount::type_prefix(private::Token), "u");
-        assert_eq!(SignedAmount::type_prefix(private::Token), "i");
-    }
+    use serde::{Deserialize, Serialize};
+
+    use crate::amount::{self, Amount, SignedAmount};
 
     #[test]
     fn can_serde_as_sat() {
@@ -410,16 +360,18 @@ mod tests {
         pub struct HasAmount {
             #[serde(with = "amount::serde::as_sat")]
             pub amount: Amount,
+            #[serde(with = "amount::serde::as_sat")]
+            pub signed_amount: SignedAmount,
         }
 
-        let orig = HasAmount { amount: Amount::ONE_BTC };
+        let orig = HasAmount { amount: Amount::ONE_BTC, signed_amount: SignedAmount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
-        let want = "{\"amount\":100000000}";
+        let want = "{\"amount\":100000000,\"signed_amount\":100000000}";
         assert_eq!(json, want);
 
-        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
-        assert_eq!(rinsed, orig);
+        let roundtrip: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(roundtrip, orig);
     }
 
     #[test]
@@ -429,16 +381,18 @@ mod tests {
         pub struct HasAmount {
             #[serde(with = "amount::serde::as_btc")]
             pub amount: Amount,
+            #[serde(with = "amount::serde::as_btc")]
+            pub signed_amount: SignedAmount,
         }
 
-        let orig = HasAmount { amount: Amount::ONE_BTC };
+        let orig = HasAmount { amount: Amount::ONE_BTC, signed_amount: SignedAmount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
-        let want = "{\"amount\":1.0}";
+        let want = "{\"amount\":1.0,\"signed_amount\":1.0}";
         assert_eq!(json, want);
 
-        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
-        assert_eq!(rinsed, orig);
+        let roundtrip: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(roundtrip, orig);
     }
 
     #[test]
@@ -448,15 +402,17 @@ mod tests {
         pub struct HasAmount {
             #[serde(with = "amount::serde::as_str")]
             pub amount: Amount,
+            #[serde(with = "amount::serde::as_str")]
+            pub signed_amount: SignedAmount,
         }
 
-        let orig = HasAmount { amount: Amount::ONE_BTC };
+        let orig = HasAmount { amount: Amount::ONE_BTC, signed_amount: SignedAmount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
-        let want = "{\"amount\":\"1\"}";
+        let want = "{\"amount\":\"1\",\"signed_amount\":\"1\"}";
         assert_eq!(json, want);
 
-        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
-        assert_eq!(rinsed, orig);
+        let roundtrip: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(roundtrip, orig);
     }
 }
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index c033eb316a..337dbb3b74 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -95,6 +95,7 @@ mod encapsulate {
 }
 #[doc(inline)]
 pub use encapsulate::SignedAmount;
+use internals::const_casts;
 
 impl SignedAmount {
     /// The zero amount.
@@ -112,11 +113,12 @@ impl SignedAmount {
     ///
     /// Accepts an `i32` which is guaranteed to be in range for the type, but which can only
     /// represent roughly -21.47 to 21.47 BTC.
+    #[allow(clippy::missing_panics_doc)]
     pub const fn from_sat_i32(satoshi: i32) -> Self {
         let sats = satoshi as i64; // cannot use i64::from in a constfn
         match Self::from_sat(sats) {
             Ok(amount) => amount,
-            Err(_) => panic!("unreachable - 32,767 BTC is within range"),
+            Err(_) => panic!("unreachable - i32 input [-2,147,483,648 to 2,147,483,647 satoshis] is within range"),
         }
     }
 
@@ -151,7 +153,7 @@ impl SignedAmount {
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
     pub const fn from_btc_i16(whole_bitcoin: i16) -> Self {
-        let btc = whole_bitcoin as i64; // Can't call `into` in const context.
+        let btc = const_casts::i16_to_i64(whole_bitcoin);
         let sats = btc * 100_000_000;
 
         match Self::from_sat(sats) {
@@ -316,6 +318,7 @@ impl SignedAmount {
     ///
     /// This function never overflows or panics, unlike `i64::abs()`.
     #[must_use]
+    #[allow(clippy::missing_panics_doc)]
     pub const fn abs(self) -> Self {
         // `i64::abs()` can never overflow because SignedAmount::MIN == -MAX_MONEY.
         match Self::from_sat(self.to_sat().abs()) {
@@ -357,7 +360,7 @@ impl SignedAmount {
     ///
     /// Returns [`None`] if overflow occurred. (`self == i64::MIN`)
     #[must_use]
-    #[deprecated(since = "TBD", note = "Never returns none, use `abs()` instead")]
+    #[deprecated(since = "1.0.0-rc.0", note = "Never returns none, use `abs()` instead")]
     #[allow(clippy::unnecessary_wraps)] // To match stdlib function definition.
     pub const fn checked_abs(self) -> Option<Self> { Some(self.abs()) }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index ebff58af59..df3672ad8c 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -10,13 +10,12 @@ use core::num::{NonZeroI64, NonZeroU64};
 #[cfg(feature = "std")]
 use std::panic;
 
-#[cfg(feature = "serde")]
-use ::serde::{Deserialize, Serialize};
-
 use super::*;
 #[cfg(feature = "alloc")]
+use crate::result::MathOp;
+use crate::result::NumOpResult;
+#[cfg(feature = "alloc")]
 use crate::{FeeRate, Weight};
-use crate::{MathOp, NumOpResult};
 
 #[track_caller]
 fn sat(sat: u64) -> Amount { Amount::from_sat(sat).unwrap() }
@@ -55,8 +54,14 @@ fn sanity_check() {
 
 #[test]
 fn check_if_num_is_too_precise() {
-    assert_eq!(is_too_precise("1234", 3).unwrap(), 3);
-    assert_eq!(is_too_precise("1234.1234", 3).unwrap(), 3);
+    // Has decimal, not too precise
+    assert_eq!(is_too_precise("1234.5678", 4), Some(0));
+    // Has decimal, is too precise
+    assert_eq!(is_too_precise("1234.5678", 3), Some(3));
+    // No decimal, not too precise
+    assert_eq!(is_too_precise("1234", 4), Some(0));
+    // No decimal, is too precise
+    assert_eq!(is_too_precise("1234", 2), Some(3));
 }
 
 #[test]
@@ -67,7 +72,7 @@ fn from_str_zero() {
         for v in &["0", "000"] {
             let s = format!("{} {}", v, denom);
             match s.parse::<Amount>() {
-                Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
+                Err(e) => panic!("failed to create amount from {}: {:?}", s, e),
                 Ok(amount) => assert_eq!(amount, Amount::ZERO),
             }
         }
@@ -83,7 +88,7 @@ fn from_str_zero() {
             Ok(_) => panic!("unsigned amount from {}", s),
         }
         match s.parse::<SignedAmount>() {
-            Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
+            Err(e) => panic!("failed to create amount from {}: {:?}", s, e),
             Ok(amount) => assert_eq!(amount, SignedAmount::ZERO),
         }
     }
@@ -230,6 +235,10 @@ fn add() {
     assert!(ssat(-127) + ssat(179) == ssat(52).into());
     assert!(ssat(127) + ssat(-179) == ssat(-52).into());
     assert!(ssat(-127) + ssat(-179) == ssat(-306).into());
+
+    // Implemented using generic impl.
+    assert!(res(127) + sat(179) == sat(306).into());
+    assert!(sres(127) + ssat(179) == ssat(306).into());
 }
 
 #[test]
@@ -243,6 +252,10 @@ fn sub() {
     assert!(ssat(-127) - ssat(179) == ssat(-306).into());
     assert!(ssat(127) - ssat(-179) == ssat(306).into());
     assert!(ssat(-127) - ssat(-179) == ssat(52).into());
+
+    // Implemented using generic impl.
+    assert!(res(179) - sat(127) == sat(52).into());
+    assert!(sres(179) - ssat(127) == ssat(52).into());
 }
 
 #[test]
@@ -259,85 +272,86 @@ fn checked_arithmetic() {
 #[test]
 fn positive_sub() {
     assert_eq!(ssat(10).positive_sub(ssat(7)).unwrap(), ssat(3));
+    assert_eq!(ssat(10).positive_sub(ssat(10)).unwrap(), ssat(0));
     assert!(ssat(-10).positive_sub(ssat(7)).is_none());
     assert!(ssat(10).positive_sub(ssat(-7)).is_none());
     assert!(ssat(10).positive_sub(ssat(11)).is_none());
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn amount_checked_div_by_weight_ceil() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = sat(1).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = sat(1).div_by_weight_ceil(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = sat(329).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = sat(329).div_by_weight_ceil(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round up to 864
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(864));
 
-    let fee_rate = Amount::ONE_SAT.checked_div_by_weight_ceil(Weight::ZERO);
-    assert!(fee_rate.is_none());
+    let fee_rate = Amount::ONE_SAT.div_by_weight_ceil(Weight::ZERO);
+    assert!(fee_rate.is_error());
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn amount_checked_div_by_weight_floor() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = sat(1).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = sat(1).div_by_weight_floor(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = sat(329).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = sat(329).div_by_weight_floor(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round down to 863
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
 
-    let fee_rate = Amount::ONE_SAT.checked_div_by_weight_floor(Weight::ZERO);
-    assert!(fee_rate.is_none());
+    let fee_rate = Amount::ONE_SAT.div_by_weight_floor(Weight::ZERO);
+    assert!(fee_rate.is_error());
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn amount_checked_div_by_fee_rate() {
     let amount = sat(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(2);
 
     // Test floor division
-    let weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
+    let weight = amount.div_by_fee_rate_floor(fee_rate).unwrap();
     // 1000 sats / (2 sats/kwu) = 500,000 wu
     assert_eq!(weight, Weight::from_wu(500_000));
 
     // Test ceiling division
-    let weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+    let weight = amount.div_by_fee_rate_ceil(fee_rate).unwrap();
     assert_eq!(weight, Weight::from_wu(500_000)); // Same result for exact division
 
     // Test truncation behavior
     let amount = sat(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(3);
-    let floor_weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
-    let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+    let floor_weight = amount.div_by_fee_rate_floor(fee_rate).unwrap();
+    let ceil_weight = amount.div_by_fee_rate_ceil(fee_rate).unwrap();
     assert_eq!(floor_weight, Weight::from_wu(333_333));
     assert_eq!(ceil_weight, Weight::from_wu(333_334));
 
     // Test division by zero
     let zero_fee_rate = FeeRate::from_sat_per_kwu(0);
-    assert!(amount.checked_div_by_fee_rate_floor(zero_fee_rate).is_none());
-    assert!(amount.checked_div_by_fee_rate_ceil(zero_fee_rate).is_none());
+    assert!(amount.div_by_fee_rate_floor(zero_fee_rate).is_error());
+    assert!(amount.div_by_fee_rate_ceil(zero_fee_rate).is_error());
 
     // Test with maximum amount
     let max_amount = Amount::MAX;
     let small_fee_rate = FeeRate::from_sat_per_kwu(1);
-    let weight = max_amount.checked_div_by_fee_rate_floor(small_fee_rate).unwrap();
+    let weight = max_amount.div_by_fee_rate_floor(small_fee_rate).unwrap();
     // 21_000_000_0000_0000 sats / (1 sat/kwu) = 2_100_000_000_000_000_000 wu
     assert_eq!(weight, Weight::from_wu(2_100_000_000_000_000_000));
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn floating_point() {
     use super::Denomination as D;
     let f = Amount::from_float_in;
@@ -463,8 +477,8 @@ fn to_string() {
 }
 
 // May help identify a problem sooner
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn test_repeat_char() {
     let mut buf = String::new();
     repeat_char(&mut buf, '0', 0).unwrap();
@@ -474,7 +488,7 @@ fn test_repeat_char() {
     assert!(buf.chars().all(|c| c == '0'));
 }
 
-// Creates individual test functions to make it easier to find which check failed.
+// Constructs individual test functions to make it easier to find which check failed.
 macro_rules! check_format_non_negative {
     ($denom:ident; $($test_name:ident, $val:literal, $format_string:literal, $expected:literal);* $(;)?) => {
         $(
@@ -647,9 +661,7 @@ fn unsigned_signed_conversion() {
 #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
 #[allow(clippy::items_after_statements)] // Define functions where we use them.
 fn from_str() {
-    use ParseDenominationError::*;
-
-    use super::ParseAmountError as E;
+    use super::{ParseAmountError as E, ParseDenominationError};
 
     assert_eq!(
         "x BTC".parse::<Amount>(),
@@ -657,11 +669,11 @@ fn from_str() {
     );
     assert_eq!(
         "xBTC".parse::<Amount>(),
-        Err(Unknown(UnknownDenominationError("xBTC".into())).into()),
+        Err(ParseDenominationError::Unknown(UnknownDenominationError("xBTC".into())).into()),
     );
     assert_eq!(
         "5 BTC BTC".parse::<Amount>(),
-        Err(Unknown(UnknownDenominationError("BTC BTC".into())).into()),
+        Err(ParseDenominationError::Unknown(UnknownDenominationError("BTC BTC".into())).into()),
     );
     assert_eq!(
         "5BTC BTC".parse::<Amount>(),
@@ -669,7 +681,7 @@ fn from_str() {
     );
     assert_eq!(
         "5 5 BTC".parse::<Amount>(),
-        Err(Unknown(UnknownDenominationError("5 BTC".into())).into()),
+        Err(ParseDenominationError::Unknown(UnknownDenominationError("5 BTC".into())).into()),
     );
 
     #[track_caller]
@@ -698,7 +710,7 @@ fn from_str() {
         assert_eq!(s.replace(' ', "").parse::<SignedAmount>(), expected);
     }
 
-    case("5 BCH", Err(Unknown(UnknownDenominationError("BCH".into()))));
+    case("5 BCH", Err(ParseDenominationError::Unknown(UnknownDenominationError("BCH".into()))));
 
     case("-1 BTC", Err(OutOfRangeError::negative()));
     case("-0.0 BTC", Err(OutOfRangeError::negative()));
@@ -712,6 +724,9 @@ fn from_str() {
     scase("2100000000000001 SAT", Err(OutOfRangeError::too_big(true)));
     case("21000001 BTC", Err(OutOfRangeError::too_big(false)));
     case("18446744073709551616 sat", Err(OutOfRangeError::too_big(false)));
+    case("_1000 sat", Err(BadPositionError { char: '_', position: 0 }));
+    case("10__00 sat", Err(BadPositionError { char: '_', position: 3 }));
+    scase("-_10_00 sat", Err(BadPositionError { char: '_', position: 1 }));
 
     ok_case(".5 bits", sat(50));
     ok_scase("-.5 bits", ssat(-50));
@@ -722,10 +737,13 @@ fn from_str() {
     ok_case("21000000 BTC", Amount::MAX);
     ok_scase("21000000 BTC", SignedAmount::MAX);
     ok_scase("-21000000 BTC", SignedAmount::MIN);
+    ok_case("1_000 sat", sat(1000));
+    ok_case("1_0_0_0_0_0_0 satoshi", sat(1_000_000));
+    ok_scase("-0_._0_10_00 BTC", ssat(-1_000_000));
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
 fn to_from_string_in() {
     use super::Denomination as D;
@@ -801,12 +819,10 @@ fn to_from_string_in() {
     );
 }
 
-#[cfg(feature = "alloc")]
 #[test]
+#[cfg(feature = "alloc")]
 fn to_string_with_denomination_from_str_roundtrip() {
-    use ParseDenominationError::*;
-
-    use super::Denomination as D;
+    use super::{Denomination as D, ParseDenominationError};
 
     let amt = sat(42);
     let denom = Amount::to_string_with_denomination;
@@ -819,281 +835,46 @@ fn to_string_with_denomination_from_str_roundtrip() {
 
     assert_eq!(
         "42 satoshi BTC".parse::<Amount>(),
-        Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()),
+        Err(ParseDenominationError::Unknown(UnknownDenominationError("satoshi BTC".into())).into(),),
     );
     assert_eq!(
         "-42 satoshi BTC".parse::<SignedAmount>(),
-        Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()),
-    );
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn serde_as_sat() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct T {
-        #[serde(with = "crate::amount::serde::as_sat")]
-        pub amt: Amount,
-        #[serde(with = "crate::amount::serde::as_sat")]
-        pub samt: SignedAmount,
-    }
-
-    serde_test::assert_tokens(
-        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
-        &[
-            serde_test::Token::Struct { name: "T", len: 2 },
-            serde_test::Token::Str("amt"),
-            serde_test::Token::U64(123_456_789),
-            serde_test::Token::Str("samt"),
-            serde_test::Token::I64(-123_456_789),
-            serde_test::Token::StructEnd,
-        ],
-    );
-}
-
-#[cfg(feature = "serde")]
-#[cfg(feature = "alloc")]
-#[test]
-#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
-fn serde_as_btc() {
-    use serde_json;
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct T {
-        #[serde(with = "crate::amount::serde::as_btc")]
-        pub amt: Amount,
-        #[serde(with = "crate::amount::serde::as_btc")]
-        pub samt: SignedAmount,
-    }
-
-    let orig = T { amt: sat(20_000_000__000_000_01), samt: ssat(-20_000_000__000_000_01) };
-
-    let json = "{\"amt\": 20000000.00000001, \
-                \"samt\": -20000000.00000001}";
-    let t: T = serde_json::from_str(json).unwrap();
-    assert_eq!(t, orig);
-
-    let value: serde_json::Value = serde_json::from_str(json).unwrap();
-    assert_eq!(t, serde_json::from_value(value).unwrap());
-
-    // errors
-    let t: Result<T, serde_json::Error> =
-        serde_json::from_str("{\"amt\": 1000000.000000001, \"samt\": 1}");
-    assert!(t.unwrap_err().to_string().contains(
-        &ParseAmountError(ParseAmountErrorInner::TooPrecise(TooPreciseError { position: 16 }))
-            .to_string()
-    ));
-    let t: Result<T, serde_json::Error> = serde_json::from_str("{\"amt\": -1, \"samt\": 1}");
-    assert!(t.unwrap_err().to_string().contains(&OutOfRangeError::negative().to_string()));
-}
-
-#[cfg(feature = "serde")]
-#[cfg(feature = "alloc")]
-#[test]
-fn serde_as_str() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct T {
-        #[serde(with = "crate::amount::serde::as_str")]
-        pub amt: Amount,
-        #[serde(with = "crate::amount::serde::as_str")]
-        pub samt: SignedAmount,
-    }
-
-    serde_test::assert_tokens(
-        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
-        &[
-            serde_test::Token::Struct { name: "T", len: 2 },
-            serde_test::Token::String("amt"),
-            serde_test::Token::String("1.23456789"),
-            serde_test::Token::String("samt"),
-            serde_test::Token::String("-1.23456789"),
-            serde_test::Token::StructEnd,
-        ],
+        Err(ParseDenominationError::Unknown(UnknownDenominationError("satoshi BTC".into())).into(),),
     );
 }
 
-#[cfg(feature = "serde")]
-#[cfg(feature = "alloc")]
-#[test]
-#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
-fn serde_as_btc_opt() {
-    use serde_json;
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
-    struct T {
-        #[serde(default, with = "crate::amount::serde::as_btc::opt")]
-        pub amt: Option<Amount>,
-        #[serde(default, with = "crate::amount::serde::as_btc::opt")]
-        pub samt: Option<SignedAmount>,
-    }
-
-    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
-    let without = T { amt: None, samt: None };
-
-    // Test Roundtripping
-    for s in [&with, &without] {
-        let v = serde_json::to_string(s).unwrap();
-        let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, *s);
-    }
-
-    let t: T = serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
-    assert_eq!(t, with);
-
-    let t: T = serde_json::from_str("{}").unwrap();
-    assert_eq!(t, without);
-
-    let value_with: serde_json::Value =
-        serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
-    assert_eq!(with, serde_json::from_value(value_with).unwrap());
-
-    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
-    assert_eq!(without, serde_json::from_value(value_without).unwrap());
-}
-
-#[cfg(feature = "serde")]
-#[cfg(feature = "alloc")]
-#[test]
-#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
-fn serde_as_sat_opt() {
-    use serde_json;
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
-    struct T {
-        #[serde(default, with = "crate::amount::serde::as_sat::opt")]
-        pub amt: Option<Amount>,
-        #[serde(default, with = "crate::amount::serde::as_sat::opt")]
-        pub samt: Option<SignedAmount>,
-    }
-
-    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
-    let without = T { amt: None, samt: None };
-
-    // Test Roundtripping
-    for s in [&with, &without] {
-        let v = serde_json::to_string(s).unwrap();
-        let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, *s);
-    }
-
-    let t: T = serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
-    assert_eq!(t, with);
-
-    let t: T = serde_json::from_str("{}").unwrap();
-    assert_eq!(t, without);
-
-    let value_with: serde_json::Value =
-        serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
-    assert_eq!(with, serde_json::from_value(value_with).unwrap());
-
-    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
-    assert_eq!(without, serde_json::from_value(value_without).unwrap());
-}
-
-#[cfg(feature = "serde")]
-#[cfg(feature = "alloc")]
-#[test]
-#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
-fn serde_as_str_opt() {
-    use serde_json;
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
-    struct T {
-        #[serde(default, with = "crate::amount::serde::as_str::opt")]
-        pub amt: Option<Amount>,
-        #[serde(default, with = "crate::amount::serde::as_str::opt")]
-        pub samt: Option<SignedAmount>,
-    }
-
-    let with = T { amt: Some(sat(123_456_789)), samt: Some(ssat(-123_456_789)) };
-    let without = T { amt: None, samt: None };
-
-    // Test Roundtripping
-    for s in [&with, &without] {
-        let v = serde_json::to_string(s).unwrap();
-        let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, *s);
-    }
-
-    let t: T =
-        serde_json::from_str("{\"amt\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
-    assert_eq!(t, with);
-
-    let t: T = serde_json::from_str("{}").unwrap();
-    assert_eq!(t, without);
-
-    let value_with: serde_json::Value =
-        serde_json::from_str("{\"amt\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
-    assert_eq!(with, serde_json::from_value(value_with).unwrap());
-
-    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
-    assert_eq!(without, serde_json::from_value(value_without).unwrap());
-}
-
 #[test]
 fn sum_amounts() {
-    assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
-    assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
-
-    let results =
-        [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
-    assert_eq!(results.iter().sum::<NumOpResult<Amount>>(), NumOpResult::Valid(sat(1400)));
-
-    let signed_results = [
-        NumOpResult::Valid(ssat(42)),
-        NumOpResult::Valid(ssat(1337)),
-        NumOpResult::Valid(ssat(21)),
-    ];
-    assert_eq!(
-        signed_results.iter().sum::<NumOpResult<SignedAmount>>(),
-        NumOpResult::Valid(ssat(1400))
-    );
+    let empty: [NumOpResult<Amount>; 0] = [];
+    assert_eq!(empty.into_iter().sum::<NumOpResult<_>>(), NumOpResult::Valid(Amount::ZERO));
+    let empty: [NumOpResult<SignedAmount>; 0] = [];
+    assert_eq!(empty.into_iter().sum::<NumOpResult<_>>(), NumOpResult::Valid(SignedAmount::ZERO));
 
     let amounts = [sat(42), sat(1337), sat(21)];
-    assert_eq!(
-        amounts.iter().map(|a| NumOpResult::Valid(*a)).sum::<NumOpResult<Amount>>(),
-        sat(1400).into(),
-    );
-    assert_eq!(
-        amounts.into_iter().map(NumOpResult::Valid).sum::<NumOpResult<Amount>>(),
-        sat(1400).into(),
-    );
-
-    let amounts = [ssat(-42), ssat(1337), ssat(21)];
-    assert_eq!(
-        amounts.iter().map(NumOpResult::from).sum::<NumOpResult<SignedAmount>>(),
-        ssat(1316).into(),
-    );
-    assert_eq!(
-        amounts.into_iter().map(NumOpResult::from).sum::<NumOpResult<SignedAmount>>(),
-        ssat(1316).into()
-    );
-}
-
-#[test]
-fn checked_sum_amounts() {
-    assert_eq!([].into_iter().checked_sum(), Some(Amount::ZERO));
-    assert_eq!([].into_iter().checked_sum(), Some(SignedAmount::ZERO));
-
-    let amounts = [sat(42), sat(1337), sat(21)];
-    let sum = amounts.into_iter().checked_sum();
-    assert_eq!(sum, Some(sat(1400)));
+    let sum = amounts.into_iter().map(NumOpResult::from).sum::<NumOpResult<Amount>>().unwrap();
+    assert_eq!(sum, sat(1400));
 
     let amounts = [Amount::MAX_MONEY, sat(1337), sat(21)];
-    let sum = amounts.into_iter().checked_sum();
-    assert_eq!(sum, None);
+    assert!(amounts.into_iter().map(NumOpResult::from).sum::<NumOpResult<Amount>>().is_error());
 
     let amounts = [SignedAmount::MIN, ssat(-1), ssat(21)];
-    let sum = amounts.into_iter().checked_sum();
-    assert_eq!(sum, None);
+    assert!(amounts
+        .into_iter()
+        .map(NumOpResult::from)
+        .sum::<NumOpResult<SignedAmount>>()
+        .is_error());
 
     let amounts = [SignedAmount::MAX, ssat(1), ssat(21)];
-    let sum = amounts.into_iter().checked_sum();
-    assert_eq!(sum, None);
+    assert!(amounts
+        .into_iter()
+        .map(NumOpResult::from)
+        .sum::<NumOpResult<SignedAmount>>()
+        .is_error());
 
     let amounts = [ssat(42), ssat(3301), ssat(21)];
-    let sum = amounts.into_iter().checked_sum();
-    assert_eq!(sum, Some(ssat(3364)));
+    let sum =
+        amounts.into_iter().map(NumOpResult::from).sum::<NumOpResult<SignedAmount>>().unwrap();
+    assert_eq!(sum, ssat(3364));
 }
 
 #[test]
@@ -1373,7 +1154,7 @@ fn check_const() {
     assert_eq!(Amount::MAX.to_sat() as i64, SignedAmount::MAX.to_sat());
 }
 
-// Sanity check than stdlib supports the set of reference combinations for the ops we want.
+// Sanity check that stdlib supports the set of reference combinations for the ops we want.
 #[test]
 #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
 fn sanity_all_ops() {
@@ -1554,3 +1335,47 @@ fn signed_amount_div_nonzero() {
     assert_eq!(&signed / divisor, SignedAmount::from_sat(-25).unwrap());
     assert_eq!(signed / &divisor, SignedAmount::from_sat(-25).unwrap());
 }
+
+#[test]
+fn signed_sub() {
+    // Test the core feature: cannot overflow unlike regular subtraction
+    let small = sat(100);
+    let large = sat(1000);
+
+    // Regular checked_sub would fail (returns None) for small - large
+    assert_eq!(small.checked_sub(large), None);
+
+    // But signed_sub works - this is the key feature!
+    let result = small.signed_sub(large);
+    assert_eq!(result.to_sat(), -900);
+    assert!(result.is_negative());
+
+    // Test positive result
+    let result2 = large.signed_sub(small);
+    assert_eq!(result2.to_sat(), 900);
+    assert!(result2.is_positive());
+
+    // Test zero result
+    let result3 = large.signed_sub(large);
+    assert_eq!(result3.to_sat(), 0);
+
+    // Test edge cases with maximum amounts
+    let max_diff = Amount::MAX.signed_sub(Amount::ZERO);
+    assert_eq!(max_diff.to_sat(), Amount::MAX.to_sat() as i64);
+
+    let min_diff = Amount::ZERO.signed_sub(Amount::MAX);
+    assert_eq!(min_diff.to_sat(), -(Amount::MAX.to_sat() as i64));
+
+    // Any two valid amounts will always produce a valid SignedAmount
+    // This demonstrates the "cannot overflow" property
+    let amt1 = Amount::MAX_MONEY;
+    let amt2 = sat(1);
+
+    let diff1 = amt1.signed_sub(amt2);
+    let diff2 = amt2.signed_sub(amt1);
+
+    assert!(diff1.is_positive());
+    assert!(diff2.is_negative());
+    assert_eq!(diff1.to_sat(), (Amount::MAX_MONEY.to_sat() - 1) as i64);
+    assert_eq!(diff2.to_sat(), -((Amount::MAX_MONEY.to_sat() - 1) as i64));
+}
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 33c97b4fc3..7c96ce56b7 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -9,12 +9,18 @@ use core::{default, fmt};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use internals::const_casts;
+use NumOpResult as R;
 
+#[cfg(feature = "encoding")]
+use super::error::AmountDecoderError;
 use super::error::{ParseAmountErrorInner, ParseErrorInner};
 use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Denomination, Display, DisplayStyle,
     OutOfRangeError, ParseAmountError, ParseError, SignedAmount,
 };
+use crate::result::{MathOp, NumOpError as E, NumOpResult};
+use crate::{FeeRate, Weight};
 
 mod encapsulate {
     use super::OutOfRangeError;
@@ -112,11 +118,13 @@ impl Amount {
     ///
     /// Accepts an `u32` which is guaranteed to be in range for the type, but which can only
     /// represent roughly 0 to 42.95 BTC.
+    #[allow(clippy::missing_panics_doc)]
     pub const fn from_sat_u32(satoshi: u32) -> Self {
-        let sats = satoshi as u64; // cannot use i64::from in a constfn
+        let sats = const_casts::u32_to_u64(satoshi);
         match Self::from_sat(sats) {
             Ok(amount) => amount,
-            Err(_) => panic!("unreachable - 65,536 BTC is within range"),
+            Err(_) =>
+                panic!("unreachable - u32 input [0 to 4,294,967,295 satoshis] is within range"),
         }
     }
 
@@ -151,7 +159,7 @@ impl Amount {
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
     pub const fn from_btc_u16(whole_bitcoin: u16) -> Self {
-        let btc = whole_bitcoin as u64; // Can't call `into` in const context.
+        let btc = const_casts::u16_to_u64(whole_bitcoin);
         let sats = btc * 100_000_000;
 
         match Self::from_sat(sats) {
@@ -402,6 +410,102 @@ impl Amount {
         SignedAmount::from_sat(self.to_sat() as i64) // Cast ok, signed amount and amount share positive range.
             .expect("range of Amount is within range of SignedAmount")
     }
+
+    /// Infallibly subtracts one `Amount` from another returning a [`SignedAmount`].
+    ///
+    /// Since `SignedAmount::MIN` is equivalent to `-Amount::MAX` subtraction of two signed amounts
+    /// can never overflow a `SignedAmount`.
+    #[must_use]
+    pub fn signed_sub(self, rhs: Self) -> SignedAmount {
+        (self.to_signed() - rhs.to_signed())
+            .expect("difference of two amounts is always within SignedAmount range")
+    }
+
+    /// Checked weight floor division.
+    ///
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made. See also [`Self::div_by_weight_ceil`].
+    pub const fn div_by_weight_floor(self, weight: Weight) -> NumOpResult<FeeRate> {
+        let wu = weight.to_wu();
+
+        // Mul by 1,000 because we use per/kwu.
+        if let Some(sats) = self.to_sat().checked_mul(1_000) {
+            match sats.checked_div(wu) {
+                Some(fee_rate) =>
+                    if let Ok(amount) = Self::from_sat(fee_rate) {
+                        return FeeRate::from_per_kwu(amount);
+                    },
+                None => return R::Error(E::while_doing(MathOp::Div)),
+            }
+        }
+        // Use `MathOp::Mul` because `Div` implies div by zero.
+        R::Error(E::while_doing(MathOp::Mul))
+    }
+
+    /// Checked weight ceiling division.
+    ///
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made. This method rounds up ensuring the transaction fee rate is
+    /// sufficient. See also [`Self::div_by_weight_floor`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{amount, Amount, FeeRate, Weight};
+    /// let amount = Amount::from_sat(10)?;
+    /// let weight = Weight::from_wu(300);
+    /// let fee_rate = amount.div_by_weight_ceil(weight).expect("valid fee rate");
+    /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
+    /// # Ok::<_, amount::OutOfRangeError>(())
+    /// ```
+    pub const fn div_by_weight_ceil(self, weight: Weight) -> NumOpResult<FeeRate> {
+        let wu = weight.to_wu();
+        if wu == 0 {
+            return R::Error(E::while_doing(MathOp::Div));
+        }
+
+        // Mul by 1,000 because we use per/kwu.
+        if let Some(sats) = self.to_sat().checked_mul(1_000) {
+            // No need to use checked arithmetic because wu is non-zero.
+            let fee_rate = sats.div_ceil(wu);
+            if let Ok(amount) = Self::from_sat(fee_rate) {
+                return FeeRate::from_per_kwu(amount);
+            }
+        }
+        // Use `MathOp::Mul` because `Div` implies div by zero.
+        R::Error(E::while_doing(MathOp::Mul))
+    }
+
+    /// Checked fee rate floor division.
+    ///
+    /// Computes the maximum weight that would result in a fee less than or equal to this amount
+    /// at the given `fee_rate`. Uses floor division to ensure the resulting weight doesn't cause
+    /// the fee to exceed the amount.
+    pub const fn div_by_fee_rate_floor(self, fee_rate: FeeRate) -> NumOpResult<Weight> {
+        debug_assert!(Self::MAX.to_sat().checked_mul(1_000).is_some());
+        let msats = self.to_sat() * 1_000;
+        match msats.checked_div(fee_rate.to_sat_per_kwu_ceil()) {
+            Some(wu) => R::Valid(Weight::from_wu(wu)),
+            None => R::Error(E::while_doing(MathOp::Div)),
+        }
+    }
+
+    /// Checked fee rate ceiling division.
+    ///
+    /// Computes the minimum weight that would result in a fee greater than or equal to this amount
+    /// at the given `fee_rate`. Uses ceiling division to ensure the resulting weight is sufficient.
+    pub const fn div_by_fee_rate_ceil(self, fee_rate: FeeRate) -> NumOpResult<Weight> {
+        // Use ceil because result is used as the divisor.
+        let rate = fee_rate.to_sat_per_kwu_ceil();
+        // Early return so we do not have to use checked arithmetic below.
+        if rate == 0 {
+            return R::Error(E::while_doing(MathOp::Div));
+        }
+
+        debug_assert!(Self::MAX.to_sat().checked_mul(1_000).is_some());
+        let msats = self.to_sat() * 1_000;
+        NumOpResult::Valid(Weight::from_wu(msats.div_ceil(rate)))
+    }
 }
 
 impl default::Default for Amount {
@@ -452,6 +556,61 @@ impl TryFrom<SignedAmount> for Amount {
     fn try_from(value: SignedAmount) -> Result<Self, Self::Error> { value.to_unsigned() }
 }
 
+#[cfg(feature = "encoding")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`Amount`] type.
+    pub struct AmountEncoder(encoding::ArrayEncoder<8>);
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Encodable for Amount {
+    type Encoder<'e> = AmountEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AmountEncoder(encoding::ArrayEncoder::without_length_prefix(self.to_sat().to_le_bytes()))
+    }
+}
+
+/// The decoder for the [`Amount`] type.
+#[cfg(feature = "encoding")]
+pub struct AmountDecoder(encoding::ArrayDecoder<8>);
+
+#[cfg(feature = "encoding")]
+impl AmountDecoder {
+    /// Constructs a new [`Amount`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+#[cfg(feature = "encoding")]
+impl Default for AmountDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for AmountDecoder {
+    type Output = Amount;
+    type Error = AmountDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(AmountDecoderError::eof)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let a = u64::from_le_bytes(self.0.end().map_err(AmountDecoderError::eof)?);
+        Amount::from_sat(a).map_err(AmountDecoderError::out_of_range)
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for Amount {
+    type Decoder = AmountDecoder;
+    fn decoder() -> Self::Decoder { AmountDecoder(encoding::ArrayDecoder::<8>::new()) }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index f8c988608a..1696f4e28f 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -4,7 +4,7 @@
 
 use std::cmp;
 
-use super::*;
+use super::{Amount, SignedAmount};
 
 // Note regarding the `unwind` parameter: this defines how many iterations
 // of loops kani will unwind before handing off to the SMT solver. Basically
diff --git a/units/src/block.rs b/units/src/block.rs
index 4efe0547b5..41c38beffc 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -6,17 +6,21 @@
 //!
 //! These are general types for abstracting over block heights, they are not designed to use with
 //! lock times. If you are creating lock times you should be using the
-//! [`locktime::absolute::Height`] and [`locktime::relative::Height`] types.
+//! [`locktime::absolute::Height`] and [`locktime::relative::NumberOfBlocks`] types.
 //!
 //! The difference between these types and the locktime types is that these types are thin wrappers
 //! whereas the locktime types contain more complex locktime specific abstractions.
 
+#[cfg(feature = "encoding")]
+use core::convert::Infallible;
 use core::{fmt, ops};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+#[cfg(feature = "encoding")]
+use internals::write_err;
 #[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(doc)]
 use crate::locktime;
@@ -30,28 +34,11 @@ macro_rules! impl_u32_wrapper {
         $(#[$($type_attrs)*])*
         $type_vis struct $newtype($inner_vis u32);
 
-        impl $newtype {
-            /// Block height 0, the genesis block.
-            pub const ZERO: Self = Self(0);
-
-            /// The minimum block height (0), the genesis block.
-            pub const MIN: Self = Self::ZERO;
-
-            /// The maximum block height.
-            pub const MAX: Self = Self(u32::MAX);
-
-            /// Constructs a new block height from a `u32`.
-            pub const fn from_u32(inner: u32) -> Self { Self(inner) }
-
-            /// Returns block height as a `u32`.
-            pub const fn to_u32(self) -> u32 { self.0 }
-        }
-
         impl fmt::Display for $newtype {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
         }
 
-        crate::impl_parse_str_from_int_infallible!($newtype, u32, from);
+        crate::parse_int::impl_parse_str_from_int_infallible!($newtype, u32, from);
 
         impl From<u32> for $newtype {
             fn from(inner: u32) -> Self { Self::from_u32(inner) }
@@ -61,6 +48,28 @@ macro_rules! impl_u32_wrapper {
             fn from(height: $newtype) -> Self { height.to_u32() }
         }
 
+        #[cfg(feature = "serde")]
+        impl Serialize for $newtype {
+            #[inline]
+            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                u32::serialize(&self.to_u32(), s)
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl<'de> Deserialize<'de> for $newtype {
+            #[inline]
+            fn deserialize<D>(d: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                Ok(Self::from_u32(u32::deserialize(d)?))
+            }
+        }
+
         #[cfg(feature = "arbitrary")]
         impl<'a> Arbitrary<'a> for $newtype {
             fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
@@ -84,19 +93,35 @@ impl_u32_wrapper! {
     ///
     /// This is a thin wrapper around a `u32` that may take on all values of a `u32`.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
     pub struct BlockHeight(u32);
 }
 
 impl BlockHeight {
-    /// Attempt to subtract two [`BlockHeight`]s, returning `None` in case of overflow.
+    /// Block height 0, the genesis block.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum block height (0), the genesis block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum block height.
+    pub const MAX: Self = Self(u32::MAX);
+
+    /// Constructs a new block height from a `u32`.
+    pub const fn from_u32(inner: u32) -> Self { Self(inner) }
+
+    /// Returns block height as a `u32`.
+    pub const fn to_u32(self) -> u32 { self.0 }
+
+    /// Attempt to subtract two [`BlockHeight`]s, returning `None` if overflow occurred.
+    #[must_use]
     pub fn checked_sub(self, other: Self) -> Option<BlockHeightInterval> {
-        self.0.checked_sub(other.0).map(BlockHeightInterval)
+        self.to_u32().checked_sub(other.to_u32()).map(BlockHeightInterval)
     }
 
-    /// Attempt to add an interval to this [`BlockHeight`], returning `None` in case of overflow.
+    /// Attempt to add an interval to this [`BlockHeight`], returning `None` if overflow occurred.
+    #[must_use]
     pub fn checked_add(self, other: BlockHeightInterval) -> Option<Self> {
-        self.0.checked_add(other.0).map(Self)
+        self.to_u32().checked_add(other.to_u32()).map(Self)
     }
 }
 
@@ -115,29 +140,126 @@ impl TryFrom<BlockHeight> for absolute::Height {
     ///
     /// An absolute locktime block height has a maximum value of [`absolute::LOCK_TIME_THRESHOLD`]
     /// minus one, while [`BlockHeight`] may take the full range of `u32`.
-    fn try_from(h: BlockHeight) -> Result<Self, Self::Error> {
-        absolute::Height::from_u32(h.to_u32())
+    fn try_from(h: BlockHeight) -> Result<Self, Self::Error> { Self::from_u32(h.to_u32()) }
+}
+
+#[cfg(feature = "encoding")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`BlockHeight`] type.
+    pub struct BlockHeightEncoder(encoding::ArrayEncoder<4>);
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Encodable for BlockHeight {
+    type Encoder<'e> = BlockHeightEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        BlockHeightEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_u32().to_le_bytes(),
+        ))
+    }
+}
+
+/// The decoder for the [`BlockHeight`] type.
+#[cfg(feature = "encoding")]
+pub struct BlockHeightDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl Default for BlockHeightDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "encoding")]
+impl BlockHeightDecoder {
+    /// Constructs a new [`BlockHeight`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for BlockHeightDecoder {
+    type Output = BlockHeight;
+    type Error = BlockHeightDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(BlockHeightDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end().map_err(BlockHeightDecoderError)?);
+        Ok(BlockHeight::from_u32(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for BlockHeight {
+    type Decoder = BlockHeightDecoder;
+    fn decoder() -> Self::Decoder { BlockHeightDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `BlockHeight`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockHeightDecoderError(encoding::UnexpectedEofError);
+
+#[cfg(feature = "encoding")]
+impl From<Infallible> for BlockHeightDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "encoding")]
+impl fmt::Display for BlockHeightDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "block height decoder error"; self.0)
     }
 }
 
+#[cfg(all(feature = "std", feature = "encoding"))]
+impl std::error::Error for BlockHeightDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
 impl_u32_wrapper! {
     /// An unsigned block interval.
     ///
     /// Block interval is an integer type representing a difference between the heights of two blocks.
     ///
     /// This type is not meant for constructing relative height based timelocks. It is a general
-    /// purpose block interval abstraction. For locktimes please see [`locktime::relative::Height`].
+    /// purpose block interval abstraction. For locktimes please see [`locktime::relative::NumberOfBlocks`].
     #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
     pub struct BlockHeightInterval(u32);
 }
 
 impl BlockHeightInterval {
-    /// Attempt to subtract two [`BlockHeightInterval`]s, returning `None` in case of overflow.
-    pub fn checked_sub(self, other: Self) -> Option<Self> { self.0.checked_sub(other.0).map(Self) }
+    /// Block interval 0.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum block interval, equivalent to `Self::ZERO`.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum block interval.
+    pub const MAX: Self = Self(u32::MAX);
+
+    /// Constructs a new block interval from a `u32`.
+    pub const fn from_u32(inner: u32) -> Self { Self(inner) }
+
+    /// Returns block interval as a `u32`.
+    pub const fn to_u32(self) -> u32 { self.0 }
 
-    /// Attempt to add two [`BlockHeightInterval`]s, returning `None` in case of overflow.
-    pub fn checked_add(self, other: Self) -> Option<Self> { self.0.checked_add(other.0).map(Self) }
+    /// Attempt to subtract two [`BlockHeightInterval`]s, returning `None` if overflow occurred.
+    #[must_use]
+    pub fn checked_sub(self, other: Self) -> Option<Self> {
+        self.to_u32().checked_sub(other.to_u32()).map(Self)
+    }
+
+    /// Attempt to add two [`BlockHeightInterval`]s, returning `None` if overflow occurred.
+    #[must_use]
+    pub fn checked_add(self, other: Self) -> Option<Self> {
+        self.to_u32().checked_add(other.to_u32()).map(Self)
+    }
 }
 
 impl From<relative::NumberOfBlocks> for BlockHeightInterval {
@@ -157,7 +279,7 @@ impl TryFrom<BlockHeightInterval> for relative::NumberOfBlocks {
     /// [`BlockHeightInterval`] is a thin wrapper around a `u32`, the two types are not interchangeable.
     fn try_from(h: BlockHeightInterval) -> Result<Self, Self::Error> {
         u16::try_from(h.to_u32())
-            .map(relative::NumberOfBlocks::from)
+            .map(Self::from)
             .map_err(|_| TooBigForRelativeHeightError(h.into()))
     }
 }
@@ -170,11 +292,28 @@ impl_u32_wrapper! {
     ///
     /// This is a thin wrapper around a `u32` that may take on all values of a `u32`.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
     pub struct BlockMtp(u32);
 }
 
 impl BlockMtp {
+    /// Block MTP 0.
+    ///
+    /// Since MTP is a timestamp, 0 is before Bitcoin was invented. This const may still be useful
+    /// for some use cases e.g., folding a sum of intervals.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum block MTP, equivalent to `Self::ZERO`.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum block MTP.
+    pub const MAX: Self = Self(u32::MAX);
+
+    /// Constructs a new block MTP from a `u32`.
+    pub const fn from_u32(inner: u32) -> Self { Self(inner) }
+
+    /// Returns block MTP as a `u32`.
+    pub const fn to_u32(self) -> u32 { self.0 }
+
     /// Constructs a [`BlockMtp`] by computing the median‐time‐past from the last 11 block timestamps
     ///
     /// Because block timestamps are not monotonic, this function internally sorts them;
@@ -185,14 +324,16 @@ impl BlockMtp {
         Self::from_u32(u32::from(timestamps[5]))
     }
 
-    /// Attempt to subtract two [`BlockMtp`]s, returning `None` in case of overflow.
+    /// Attempt to subtract two [`BlockMtp`]s, returning `None` if overflow occurred.
+    #[must_use]
     pub fn checked_sub(self, other: Self) -> Option<BlockMtpInterval> {
-        self.0.checked_sub(other.0).map(BlockMtpInterval)
+        self.to_u32().checked_sub(other.to_u32()).map(BlockMtpInterval)
     }
 
-    /// Attempt to add an interval to this [`BlockMtp`], returning `None` in case of overflow.
+    /// Attempt to add an interval to this [`BlockMtp`], returning `None` if overflow occurred.
+    #[must_use]
     pub fn checked_add(self, other: BlockMtpInterval) -> Option<Self> {
-        self.0.checked_add(other.0).map(Self)
+        self.to_u32().checked_add(other.to_u32()).map(Self)
     }
 }
 
@@ -211,9 +352,7 @@ impl TryFrom<BlockMtp> for absolute::MedianTimePast {
     ///
     /// An absolute locktime MTP has a minimum value of [`absolute::LOCK_TIME_THRESHOLD`],
     /// while [`BlockMtp`] may take the full range of `u32`.
-    fn try_from(h: BlockMtp) -> Result<Self, Self::Error> {
-        absolute::MedianTimePast::from_u32(h.to_u32())
-    }
+    fn try_from(h: BlockMtp) -> Result<Self, Self::Error> { Self::from_u32(h.to_u32()) }
 }
 
 impl_u32_wrapper! {
@@ -224,11 +363,25 @@ impl_u32_wrapper! {
     ///
     /// This is a thin wrapper around a `u32` that may take on all values of a `u32`.
     #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
     pub struct BlockMtpInterval(u32);
 }
 
 impl BlockMtpInterval {
+    /// Block MTP interval 0.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum block MTP interval, equivalent to `Self::ZERO`.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum block MTP interval.
+    pub const MAX: Self = Self(u32::MAX);
+
+    /// Constructs a new block MTP interval from a `u32`.
+    pub const fn from_u32(inner: u32) -> Self { Self(inner) }
+
+    /// Returns block MTP interval as a `u32`.
+    pub const fn to_u32(self) -> u32 { self.0 }
+
     /// Converts a [`BlockMtpInterval`] to a [`locktime::relative::NumberOf512Seconds`], rounding down.
     ///
     /// Relative timelock MTP intervals have a resolution of 512 seconds, while
@@ -261,11 +414,17 @@ impl BlockMtpInterval {
         relative::NumberOf512Seconds::from_seconds_ceil(self.to_u32())
     }
 
-    /// Attempt to subtract two [`BlockMtpInterval`]s, returning `None` in case of overflow.
-    pub fn checked_sub(self, other: Self) -> Option<Self> { self.0.checked_sub(other.0).map(Self) }
+    /// Attempt to subtract two [`BlockMtpInterval`]s, returning `None` if overflow occurred.
+    #[must_use]
+    pub fn checked_sub(self, other: Self) -> Option<Self> {
+        self.to_u32().checked_sub(other.to_u32()).map(Self)
+    }
 
-    /// Attempt to add two [`BlockMtpInterval`]s, returning `None` in case of overflow.
-    pub fn checked_add(self, other: Self) -> Option<Self> { self.0.checked_add(other.0).map(Self) }
+    /// Attempt to add two [`BlockMtpInterval`]s, returning `None` if overflow occurred.
+    #[must_use]
+    pub fn checked_add(self, other: Self) -> Option<Self> {
+        self.to_u32().checked_add(other.to_u32()).map(Self)
+    }
 }
 
 impl From<relative::NumberOf512Seconds> for BlockMtpInterval {
@@ -404,41 +563,42 @@ crate::internal_macros::impl_sub_assign!(BlockMtpInterval);
 
 impl core::iter::Sum for BlockHeightInterval {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sum = iter.map(|interval| interval.0).sum();
-        BlockHeightInterval::from_u32(sum)
+        let sum = iter.map(Self::to_u32).sum();
+        Self::from_u32(sum)
     }
 }
 
-impl<'a> core::iter::Sum<&'a BlockHeightInterval> for BlockHeightInterval {
+impl<'a> core::iter::Sum<&'a Self> for BlockHeightInterval {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a BlockHeightInterval>,
+        I: Iterator<Item = &'a Self>,
     {
-        let sum = iter.map(|interval| interval.0).sum();
-        BlockHeightInterval::from_u32(sum)
+        let sum = iter.map(|interval| interval.to_u32()).sum();
+        Self::from_u32(sum)
     }
 }
 
 impl core::iter::Sum for BlockMtpInterval {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sum = iter.map(|interval| interval.0).sum();
-        BlockMtpInterval::from_u32(sum)
+        let sum = iter.map(Self::to_u32).sum();
+        Self::from_u32(sum)
     }
 }
 
-impl<'a> core::iter::Sum<&'a BlockMtpInterval> for BlockMtpInterval {
+impl<'a> core::iter::Sum<&'a Self> for BlockMtpInterval {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a BlockMtpInterval>,
+        I: Iterator<Item = &'a Self>,
     {
-        let sum = iter.map(|interval| interval.0).sum();
-        BlockMtpInterval::from_u32(sum)
+        let sum = iter.map(|interval| interval.to_u32()).sum();
+        Self::from_u32(sum)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::locktime::relative::NumberOf512Seconds;
 
     #[test]
     fn sanity_check() {
@@ -479,6 +639,7 @@ mod tests {
         // interval - interval = interval
         assert!(BlockHeightInterval(10) - BlockHeightInterval(7) == BlockHeightInterval(3));
 
+        // Sum for BlockHeightInterval by reference and by value
         assert!(
             [BlockHeightInterval(1), BlockHeightInterval(2), BlockHeightInterval(3)]
                 .iter()
@@ -492,6 +653,20 @@ mod tests {
                 == BlockHeightInterval(15)
         );
 
+        // Sum for BlockMtpInterval by reference and by value
+        assert!(
+            [BlockMtpInterval(1), BlockMtpInterval(2), BlockMtpInterval(3)]
+                .iter()
+                .sum::<BlockMtpInterval>()
+                == BlockMtpInterval(6)
+        );
+        assert!(
+            [BlockMtpInterval(4), BlockMtpInterval(5), BlockMtpInterval(6)]
+                .into_iter()
+                .sum::<BlockMtpInterval>()
+                == BlockMtpInterval(15)
+        );
+
         // interval += interval
         let mut int = BlockHeightInterval(1);
         int += BlockHeightInterval(2);
@@ -502,4 +677,54 @@ mod tests {
         int -= BlockHeightInterval(7);
         assert_eq!(int, BlockHeightInterval(3));
     }
+
+    #[test]
+    fn block_height_checked() {
+        let a = BlockHeight(10);
+        let b = BlockHeight(5);
+        assert_eq!(a.checked_sub(b), Some(BlockHeightInterval(5)));
+        assert_eq!(a.checked_add(BlockHeightInterval(5)), Some(BlockHeight(15)));
+        assert_eq!(a.checked_sub(BlockHeight(11)), None);
+        assert_eq!(a.checked_add(BlockHeightInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_height_interval_checked() {
+        let a = BlockHeightInterval(10);
+        let b = BlockHeightInterval(5);
+        assert_eq!(a.checked_sub(b), Some(BlockHeightInterval(5)));
+        assert_eq!(a.checked_add(b), Some(BlockHeightInterval(15)));
+        assert_eq!(a.checked_sub(BlockHeightInterval(11)), None);
+        assert_eq!(a.checked_add(BlockHeightInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_interval_checked() {
+        let a = BlockMtpInterval(10);
+        let b = BlockMtpInterval(5);
+        assert_eq!(a.checked_sub(b), Some(BlockMtpInterval(5)));
+        assert_eq!(a.checked_add(b), Some(BlockMtpInterval(15)));
+        assert_eq!(a.checked_sub(BlockMtpInterval(11)), None);
+        assert_eq!(a.checked_add(BlockMtpInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_checked() {
+        let a = BlockMtp(10);
+        let b = BlockMtp(5);
+        assert_eq!(a.checked_sub(b), Some(BlockMtpInterval(5)));
+        assert_eq!(a.checked_add(BlockMtpInterval(5)), Some(BlockMtp(15)));
+        assert_eq!(a.checked_sub(BlockMtp(11)), None);
+        assert_eq!(a.checked_add(BlockMtpInterval(u32::MAX - 5)), None);
+    }
+
+    #[test]
+    fn block_mtp_interval_from_number_of_512seconds() {
+        let n = NumberOf512Seconds::from_seconds_floor(0).unwrap();
+        let interval = BlockMtpInterval::from(n);
+        assert_eq!(interval, BlockMtpInterval(0));
+        let n = NumberOf512Seconds::from_seconds_floor(1024).unwrap();
+        let interval = BlockMtpInterval::from(n);
+        assert_eq!(interval, BlockMtpInterval(1024));
+    }
 }
diff --git a/units/src/fee.rs b/units/src/fee.rs
index e08c9c89a0..0cd69ad8cc 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -8,166 +8,31 @@
 //! Either the weight or fee rate can be calculated if one knows the total fee and either of the
 //! other values. Note however that such calculations truncate (as for integer division).
 //!
-//! We provide `fee.checked_div_by_weight_ceil(weight)` to calculate a minimum threshold fee rate
+//! We provide `fee.div_by_weight_ceil(weight)` to calculate a minimum threshold fee rate
 //! required to pay at least `fee` for transaction with `weight`.
+//!
+//! We support various `core::ops` traits all of which return [`NumOpResult<T>`].
+//!
+//! For specific methods see:
+//!
+//! * [`Amount::div_by_weight_floor`]
+//! * [`Amount::div_by_weight_ceil`]
+//! * [`Amount::div_by_fee_rate_floor`]
+//! * [`Amount::div_by_fee_rate_ceil`]
+//! * [`Weight::mul_by_fee_rate`]
+//! * [`FeeRate::mul_by_weight`]
+//! * [`FeeRate::to_fee`]
 
 use core::ops;
 
 use NumOpResult as R;
 
-use crate::{Amount, FeeRate, MathOp, NumOpError as E, NumOpResult, OptionExt, Weight};
-
-impl Amount {
-    /// Checked weight ceiling division.
-    ///
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made. This method rounds up ensuring the transaction fee rate is
-    /// sufficient. See also [`Self::checked_div_by_weight_floor`].
-    ///
-    /// Returns [`None`] if overflow occurred.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::{amount, Amount, FeeRate, Weight};
-    /// let amount = Amount::from_sat(10)?;
-    /// let weight = Weight::from_wu(300);
-    /// let fee_rate = amount.checked_div_by_weight_ceil(weight);
-    /// assert_eq!(fee_rate, Some(FeeRate::from_sat_per_kwu(34)));
-    /// # Ok::<_, amount::OutOfRangeError>(())
-    /// ```
-    #[must_use]
-    pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
-        let wu = weight.to_wu();
-        // No `?` operator in const context.
-        if let Some(sats) = self.to_sat().checked_mul(1_000) {
-            if let Some(wu_minus_one) = wu.checked_sub(1) {
-                if let Some(sats_plus_wu_minus_one) = sats.checked_add(wu_minus_one) {
-                    if let Some(fee_rate) = sats_plus_wu_minus_one.checked_div(wu) {
-                        return Some(FeeRate::from_sat_per_kwu(fee_rate));
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    /// Checked weight floor division.
-    ///
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made. See also [`Self::checked_div_by_weight_ceil`].
-    ///
-    /// Returns [`None`] if overflow occurred.
-    #[must_use]
-    pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
-        // No `?` operator in const context.
-        match self.to_sat().checked_mul(1_000) {
-            Some(res) => match res.checked_div(weight.to_wu()) {
-                Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
-                None => None,
-            },
-            None => None,
-        }
-    }
-
-    /// Checked fee rate floor division.
-    ///
-    /// Computes the maximum weight that would result in a fee less than or equal to this amount
-    /// at the given `fee_rate`. Uses floor division to ensure the resulting weight doesn't cause
-    /// the fee to exceed the amount.
-    ///
-    /// Returns [`None`] if overflow occurred or if `fee_rate` is zero.
-    #[must_use]
-    pub const fn checked_div_by_fee_rate_floor(self, fee_rate: FeeRate) -> Option<Weight> {
-        match self.to_sat().checked_mul(1000) {
-            Some(amount_msats) => match amount_msats.checked_div(fee_rate.to_sat_per_kwu()) {
-                Some(wu) => Some(Weight::from_wu(wu)),
-                None => None,
-            },
-            None => None,
-        }
-    }
-
-    /// Checked fee rate ceiling division.
-    ///
-    /// Computes the minimum weight that would result in a fee greater than or equal to this amount
-    /// at the given `fee_rate`. Uses ceiling division to ensure the resulting weight is sufficient.
-    ///
-    /// Returns [`None`] if overflow occurred or if `fee_rate` is zero.
-    #[must_use]
-    pub const fn checked_div_by_fee_rate_ceil(self, fee_rate: FeeRate) -> Option<Weight> {
-        let rate = fee_rate.to_sat_per_kwu();
-        match self.to_sat().checked_mul(1000) {
-            Some(amount_msats) => match rate.checked_sub(1) {
-                Some(rate_minus_one) => match amount_msats.checked_add(rate_minus_one) {
-                    Some(rounded_msats) => match rounded_msats.checked_div(rate) {
-                        Some(wu) => Some(Weight::from_wu(wu)),
-                        None => None,
-                    },
-                    None => None,
-                },
-                None => None,
-            },
-            None => None,
-        }
-    }
-}
-
-impl FeeRate {
-    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning
-    /// [`NumOpResult::Error`] if an overflow occurred.
-    ///
-    /// This is equivalent to `Self::checked_mul_by_weight()`.
-    pub const fn to_fee(self, weight: Weight) -> NumOpResult<Amount> {
-        self.checked_mul_by_weight(weight)
-    }
-
-    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning [`None`]
-    /// if an overflow occurred.
-    ///
-    /// This is equivalent to `Self::checked_mul_by_weight()`.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "use `to_fee()` instead")]
-    pub fn fee_wu(self, weight: Weight) -> Option<Amount> {
-        self.checked_mul_by_weight(weight).ok()
-    }
-
-    /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
-    /// if an overflow occurred.
-    ///
-    /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
-    /// `Self::fee_wu(weight)`.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "use Weight::from_vb and then `to_fee()` instead")]
-    pub fn fee_vb(self, vb: u64) -> Option<Amount> {
-        Weight::from_vb(vb).and_then(|w| self.to_fee(w).ok())
-    }
-
-    /// Checked weight multiplication.
-    ///
-    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate. When the resulting
-    /// fee is a non-integer amount, the amount is rounded up, ensuring that the transaction fee is
-    /// enough instead of falling short if rounded down.
-    ///
-    /// Returns [`NumOpResult::Error`] if overflow occurred.
-    pub const fn checked_mul_by_weight(self, weight: Weight) -> NumOpResult<Amount> {
-        if let Some(fee) = self.to_sat_per_kwu().checked_mul(weight.to_wu()) {
-            if let Some(round_up) = fee.checked_add(999) {
-                if let Ok(ret) = Amount::from_sat(round_up / 1_000) {
-                    return NumOpResult::Valid(ret);
-                }
-            }
-        }
-        NumOpResult::Error(E::while_doing(MathOp::Mul))
-    }
-}
+use crate::{Amount, FeeRate, NumOpResult, Weight};
 
 crate::internal_macros::impl_op_for_references! {
     impl ops::Mul<FeeRate> for Weight {
         type Output = NumOpResult<Amount>;
-        fn mul(self, rhs: FeeRate) -> Self::Output {
-            rhs.checked_mul_by_weight(self)
-        }
+        fn mul(self, rhs: FeeRate) -> Self::Output { rhs.mul_by_weight(self) }
     }
     impl ops::Mul<FeeRate> for NumOpResult<Weight> {
         type Output = NumOpResult<Amount>;
@@ -202,9 +67,7 @@ crate::internal_macros::impl_op_for_references! {
 
     impl ops::Mul<Weight> for FeeRate {
         type Output = NumOpResult<Amount>;
-        fn mul(self, rhs: Weight) -> Self::Output {
-            self.checked_mul_by_weight(rhs)
-        }
+        fn mul(self, rhs: Weight) -> Self::Output { self.mul_by_weight(rhs) }
     }
     impl ops::Mul<Weight> for NumOpResult<FeeRate> {
         type Output = NumOpResult<Amount>;
@@ -241,7 +104,7 @@ crate::internal_macros::impl_op_for_references! {
         type Output = NumOpResult<FeeRate>;
 
         fn div(self, rhs: Weight) -> Self::Output {
-            self.checked_div_by_weight_floor(rhs).valid_or_error(MathOp::Div)
+            self.div_by_weight_floor(rhs)
         }
     }
     impl ops::Div<Weight> for NumOpResult<Amount> {
@@ -282,7 +145,7 @@ crate::internal_macros::impl_op_for_references! {
         type Output = NumOpResult<Weight>;
 
         fn div(self, rhs: FeeRate) -> Self::Output {
-            self.checked_div_by_fee_rate_floor(rhs).valid_or_error(MathOp::Div)
+            self.div_by_fee_rate_floor(rhs)
         }
     }
     impl ops::Div<FeeRate> for NumOpResult<Amount> {
@@ -320,19 +183,6 @@ crate::internal_macros::impl_op_for_references! {
     }
 }
 
-impl Weight {
-    /// Checked fee rate multiplication.
-    ///
-    /// Computes the absolute fee amount for a given [`FeeRate`] at this weight. When the resulting
-    /// fee is a non-integer amount, the amount is rounded up, ensuring that the transaction fee is
-    /// enough instead of falling short if rounded down.
-    ///
-    /// Returns [`None`] if overflow occurred.
-    pub const fn checked_mul_by_fee_rate(self, fee_rate: FeeRate) -> NumOpResult<Amount> {
-        fee_rate.checked_mul_by_weight(self)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -345,34 +195,29 @@ mod tests {
 
     #[test]
     fn fee_wu() {
-        let operation = FeeRate::from_sat_per_kwu(10).to_fee(Weight::MAX).unwrap_err().operation();
-        assert!(operation.is_multiplication());
-
-        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
+        let fee_rate = FeeRate::from_sat_per_vb(2);
         let weight = Weight::from_vb(3).unwrap();
-        assert_eq!(fee_rate.to_fee(weight).unwrap(), Amount::from_sat_u32(6));
+        assert_eq!(fee_rate.to_fee(weight), Amount::from_sat_u32(6));
     }
 
     #[test]
-    fn checked_weight_mul() {
+    fn weight_mul() {
         let weight = Weight::from_vb(10).unwrap();
-        let fee: Amount = FeeRate::from_sat_per_vb(10)
-            .unwrap()
-            .checked_mul_by_weight(weight)
-            .expect("expected Amount");
+        let fee: Amount =
+            FeeRate::from_sat_per_vb(10).mul_by_weight(weight).expect("expected Amount");
         assert_eq!(Amount::from_sat_u32(100), fee);
 
-        let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
+        let fee = FeeRate::from_sat_per_kwu(10).mul_by_weight(Weight::MAX);
         assert!(fee.is_error());
 
         let weight = Weight::from_vb(3).unwrap();
-        let fee_rate = FeeRate::from_sat_per_vb(3).unwrap();
-        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
+        let fee_rate = FeeRate::from_sat_per_vb(3);
+        let fee = fee_rate.mul_by_weight(weight).unwrap();
         assert_eq!(Amount::from_sat_u32(9), fee);
 
         let weight = Weight::from_wu(381);
         let fee_rate = FeeRate::from_sat_per_kwu(864);
-        let fee = weight.checked_mul_by_fee_rate(fee_rate).unwrap();
+        let fee = weight.mul_by_fee_rate(fee_rate).unwrap();
         // 381 * 0.864 yields 329.18.
         // The result is then rounded up to 330.
         assert_eq!(fee, Amount::from_sat_u32(330));
@@ -381,7 +226,7 @@ mod tests {
     #[test]
     #[allow(clippy::op_ref)]
     fn multiply() {
-        let two = FeeRate::from_sat_per_vb(2).unwrap();
+        let two = FeeRate::from_sat_per_vb(2);
         let three = Weight::from_vb(3).unwrap();
         let six = Amount::from_sat_u32(6);
 
@@ -399,8 +244,8 @@ mod tests {
         // Test exact division
         let amount = Amount::from_sat_u32(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(2);
-        let weight = (amount / fee_rate).unwrap();
-        assert_eq!(weight, Weight::from_wu(500_000));
+        let weight = amount / fee_rate;
+        assert_eq!(weight.unwrap(), Weight::from_wu(500_000));
 
         // Test reference division
         let weight_ref = (&amount / fee_rate).unwrap();
@@ -413,19 +258,19 @@ mod tests {
         // Test truncation behavior
         let amount = Amount::from_sat_u32(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(3);
-        let weight = (amount / fee_rate).unwrap();
+        let weight = amount / fee_rate;
         // 1000 * 1000 = 1,000,000 msats
         // 1,000,000 / 3 = 333,333.33... wu
         // Should truncate down to 333,333 wu
-        assert_eq!(weight, Weight::from_wu(333_333));
+        assert_eq!(weight.unwrap(), Weight::from_wu(333_333));
 
         // Verify that ceiling division gives different result
-        let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+        let ceil_weight = amount.div_by_fee_rate_ceil(fee_rate).unwrap();
         assert_eq!(ceil_weight, Weight::from_wu(333_334));
 
         // Test that division by zero returns None
         let zero_rate = FeeRate::from_sat_per_kwu(0);
-        assert!(amount.checked_div_by_fee_rate_floor(zero_rate).is_none());
-        assert!(amount.checked_div_by_fee_rate_ceil(zero_rate).is_none());
+        assert!(amount.div_by_fee_rate_floor(zero_rate).is_error());
+        assert!(amount.div_by_fee_rate_ceil(zero_rate).is_error());
     }
 }
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index 520790e370..7f4b71a3dc 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -10,86 +10,124 @@ use core::ops;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use NumOpResult as R;
+
+use crate::result::{MathOp, NumOpError as E, NumOpResult};
+use crate::{Amount, Weight};
 
 mod encapsulate {
     /// Fee rate.
     ///
-    /// This is an integer newtype representing fee rate in `sat/kwu`. It provides protection
-    /// against mixing up the types as well as basic formatting features.
+    /// This is an integer newtype representing fee rate. It provides protection
+    /// against mixing up the types, conversion functions, and basic formatting.
     #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
     pub struct FeeRate(u64);
 
     impl FeeRate {
-        /// Constructs a new [`FeeRate`] from satoshis per 1000 weight units.
-        pub const fn from_sat_per_kwu(sat_kwu: u64) -> Self { FeeRate(sat_kwu) }
+        /// Constructs a new [`FeeRate`] from satoshis per 1,000,000 virtual bytes.
+        pub(crate) const fn from_sat_per_mvb(sat_mvb: u64) -> Self { Self(sat_mvb) }
 
-        /// Returns raw fee rate.
-        ///
-        /// Can be used instead of `into()` to avoid inference issues.
-        pub const fn to_sat_per_kwu(self) -> u64 { self.0 }
+        /// Converts to sat/MvB.
+        pub(crate) const fn to_sat_per_mvb(self) -> u64 { self.0 }
     }
 }
 #[doc(inline)]
 pub use encapsulate::FeeRate;
+use internals::const_casts;
 
 impl FeeRate {
-    /// 0 sat/kwu.
+    /// The zero fee rate.
     ///
     /// Equivalent to [`MIN`](Self::MIN), may better express intent in some contexts.
-    pub const ZERO: FeeRate = FeeRate::from_sat_per_kwu(0);
+    pub const ZERO: Self = Self::from_sat_per_mvb(0);
 
-    /// Minimum possible value (0 sat/kwu).
+    /// The minimum possible value.
     ///
     /// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
-    pub const MIN: FeeRate = FeeRate::ZERO;
+    pub const MIN: Self = Self::ZERO;
 
-    /// Maximum possible value.
-    pub const MAX: FeeRate = FeeRate::from_sat_per_kwu(u64::MAX);
+    /// The maximum possible value.
+    pub const MAX: Self = Self::from_sat_per_mvb(u64::MAX);
 
-    /// Minimum fee rate required to broadcast a transaction.
+    /// The minimum fee rate required to broadcast a transaction.
     ///
     /// The value matches the default Bitcoin Core policy at the time of library release.
-    pub const BROADCAST_MIN: FeeRate = FeeRate::from_sat_per_vb_unchecked(1);
+    pub const BROADCAST_MIN: Self = Self::from_sat_per_vb(1);
 
-    /// Fee rate used to compute dust amount.
-    pub const DUST: FeeRate = FeeRate::from_sat_per_vb_unchecked(3);
+    /// The fee rate used to compute dust amount.
+    pub const DUST: Self = Self::from_sat_per_vb(3);
 
-    /// Constructs a new [`FeeRate`] from satoshis per virtual bytes.
-    ///
-    /// # Errors
-    ///
-    /// Returns [`None`] on arithmetic overflow.
-    pub fn from_sat_per_vb(sat_vb: u64) -> Option<Self> {
-        // 1 vb == 4 wu
-        // 1 sat/vb == 1/4 sat/wu
-        // sat_vb sat/vb * 1000 / 4 == sat/kwu
-        Some(FeeRate::from_sat_per_kwu(sat_vb.checked_mul(1000 / 4)?))
+    /// Constructs a new [`FeeRate`] from satoshis per 1000 weight units.
+    pub const fn from_sat_per_kwu(sat_kwu: u32) -> Self {
+        let fee_rate = (const_casts::u32_to_u64(sat_kwu)) * 4_000;
+        Self::from_sat_per_mvb(fee_rate)
     }
 
-    /// Constructs a new [`FeeRate`] from satoshis per virtual bytes without overflow check.
-    pub const fn from_sat_per_vb_unchecked(sat_vb: u64) -> Self {
-        FeeRate::from_sat_per_kwu(sat_vb * (1000 / 4))
+    /// Constructs a new [`FeeRate`] from amount per 1000 weight units.
+    pub const fn from_per_kwu(rate: Amount) -> NumOpResult<Self> {
+        // No `map()` in const context.
+        match rate.checked_mul(4_000) {
+            Some(per_mvb) => R::Valid(Self::from_sat_per_mvb(per_mvb.to_sat())),
+            None => R::Error(E::while_doing(MathOp::Mul)),
+        }
+    }
+
+    /// Constructs a new [`FeeRate`] from satoshis per virtual byte.
+    pub const fn from_sat_per_vb(sat_vb: u32) -> Self {
+        let fee_rate = (const_casts::u32_to_u64(sat_vb)) * 1_000_000;
+        Self::from_sat_per_mvb(fee_rate)
+    }
+
+    /// Constructs a new [`FeeRate`] from amount per virtual byte.
+    pub const fn from_per_vb(rate: Amount) -> NumOpResult<Self> {
+        // No `map()` in const context.
+        match rate.checked_mul(1_000_000) {
+            Some(per_mvb) => R::Valid(Self::from_sat_per_mvb(per_mvb.to_sat())),
+            None => R::Error(E::while_doing(MathOp::Mul)),
+        }
+    }
+
+    /// Constructs a new [`FeeRate`] from satoshis per kilo virtual bytes (1,000 vbytes).
+    pub const fn from_sat_per_kvb(sat_kvb: u32) -> Self {
+        let fee_rate = (const_casts::u32_to_u64(sat_kvb)) * 1_000;
+        Self::from_sat_per_mvb(fee_rate)
     }
 
     /// Constructs a new [`FeeRate`] from satoshis per kilo virtual bytes (1,000 vbytes).
-    pub const fn from_sat_per_kvb(sat_kvb: u64) -> Self { FeeRate::from_sat_per_kwu(sat_kvb / 4) }
+    pub const fn from_per_kvb(rate: Amount) -> NumOpResult<Self> {
+        // No `map()` in const context.
+        match rate.checked_mul(1_000) {
+            Some(per_mvb) => R::Valid(Self::from_sat_per_mvb(per_mvb.to_sat())),
+            None => R::Error(E::while_doing(MathOp::Mul)),
+        }
+    }
+
+    /// Converts to sat/kwu rounding down.
+    pub const fn to_sat_per_kwu_floor(self) -> u64 { self.to_sat_per_mvb() / 4_000 }
+
+    /// Converts to sat/kwu rounding up.
+    pub const fn to_sat_per_kwu_ceil(self) -> u64 { self.to_sat_per_mvb().div_ceil(4_000) }
 
     /// Converts to sat/vB rounding down.
-    pub const fn to_sat_per_vb_floor(self) -> u64 { self.to_sat_per_kwu() / (1000 / 4) }
+    pub const fn to_sat_per_vb_floor(self) -> u64 { self.to_sat_per_mvb() / 1_000_000 }
 
     /// Converts to sat/vB rounding up.
-    pub const fn to_sat_per_vb_ceil(self) -> u64 {
-        (self.to_sat_per_kwu() + (1000 / 4 - 1)) / (1000 / 4)
-    }
+    pub const fn to_sat_per_vb_ceil(self) -> u64 { self.to_sat_per_mvb().div_ceil(1_000_000) }
+
+    /// Converts to sat/kvb rounding down.
+    pub const fn to_sat_per_kvb_floor(self) -> u64 { self.to_sat_per_mvb() / 1_000 }
+
+    /// Converts to sat/kvb rounding up.
+    pub const fn to_sat_per_kvb_ceil(self) -> u64 { self.to_sat_per_mvb().div_ceil(1_000) }
 
     /// Checked multiplication.
     ///
-    /// Computes `self * rhs` returning [`None`] if overflow occurred.
+    /// Computes `self * rhs`, returning [`None`] if overflow occurred.
     #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
-        match self.to_sat_per_kwu().checked_mul(rhs) {
-            Some(res) => Some(Self::from_sat_per_kwu(res)),
+        match self.to_sat_per_mvb().checked_mul(rhs) {
+            Some(res) => Some(Self::from_sat_per_mvb(res)),
             None => None,
         }
     }
@@ -100,58 +138,104 @@ impl FeeRate {
     #[must_use]
     pub const fn checked_div(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
-        match self.to_sat_per_kwu().checked_div(rhs) {
-            Some(res) => Some(Self::from_sat_per_kwu(res)),
+        match self.to_sat_per_mvb().checked_div(rhs) {
+            Some(res) => Some(Self::from_sat_per_mvb(res)),
             None => None,
         }
     }
 
     /// Checked addition.
     ///
-    /// Computes `self + rhs` returning [`None`] if overflow occurred.
+    /// Computes `self + rhs` returning [`None`] in case of overflow.
     #[must_use]
-    pub const fn checked_add(self, rhs: u64) -> Option<Self> {
+    pub const fn checked_add(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
-        match self.to_sat_per_kwu().checked_add(rhs) {
-            Some(res) => Some(Self::from_sat_per_kwu(res)),
+        match self.to_sat_per_mvb().checked_add(rhs.to_sat_per_mvb()) {
+            Some(res) => Some(Self::from_sat_per_mvb(res)),
             None => None,
         }
     }
 
     /// Checked subtraction.
     ///
-    /// Computes `self - rhs` returning [`None`] if overflow occurred.
+    /// Computes `self - rhs`, returning [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_sub(self, rhs: u64) -> Option<Self> {
+    pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
-        match self.to_sat_per_kwu().checked_sub(rhs) {
-            Some(res) => Some(Self::from_sat_per_kwu(res)),
+        match self.to_sat_per_mvb().checked_sub(rhs.to_sat_per_mvb()) {
+            Some(res) => Some(Self::from_sat_per_mvb(res)),
             None => None,
         }
     }
-}
 
-impl From<FeeRate> for u64 {
-    fn from(value: FeeRate) -> Self { value.to_sat_per_kwu() }
+    /// Calculates the fee by multiplying this fee rate by weight.
+    ///
+    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate. When the resulting
+    /// fee is a non-integer amount, the amount is rounded up, ensuring that the transaction fee is
+    /// enough instead of falling short if rounded down.
+    ///
+    /// If the calculation would overflow we saturate to [`Amount::MAX`]. Since such a fee can never
+    /// be paid this is meaningful as an error case while still removing the possibility of silently
+    /// wrapping.
+    pub const fn to_fee(self, weight: Weight) -> Amount {
+        // No `unwrap_or()` in const context.
+        match self.mul_by_weight(weight) {
+            NumOpResult::Valid(fee) => fee,
+            NumOpResult::Error(_) => Amount::MAX,
+        }
+    }
+
+    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning [`None`]
+    /// if an overflow occurred.
+    ///
+    /// This is equivalent to `Self::mul_by_weight(weight).ok()`.
+    #[must_use]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `to_fee()` instead")]
+    pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.mul_by_weight(weight).ok() }
+
+    /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
+    /// if `vb` cannot be represented as [`Weight`].
+    ///
+    /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
+    /// [`Self::to_fee`].
+    #[must_use]
+    #[deprecated(since = "1.0.0-rc.0", note = "use Weight::from_vb and then `to_fee()` instead")]
+    pub fn fee_vb(self, vb: u64) -> Option<Amount> { Weight::from_vb(vb).map(|w| self.to_fee(w)) }
+
+    /// Checked weight multiplication.
+    ///
+    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate. When the resulting
+    /// fee is a non-integer amount, the amount is rounded up, ensuring that the transaction fee is
+    /// enough instead of falling short if rounded down.
+    pub const fn mul_by_weight(self, weight: Weight) -> NumOpResult<Amount> {
+        let wu = weight.to_wu();
+        if let Some(fee_kwu) = self.to_sat_per_kwu_floor().checked_mul(wu) {
+            let fee = fee_kwu.div_ceil(1_000);
+            if let Ok(fee_amount) = Amount::from_sat(fee) {
+                return NumOpResult::Valid(fee_amount);
+            }
+        }
+        NumOpResult::Error(E::while_doing(MathOp::Mul))
+    }
 }
 
 crate::internal_macros::impl_op_for_references! {
     impl ops::Add<FeeRate> for FeeRate {
         type Output = FeeRate;
 
-        fn add(self, rhs: FeeRate) -> Self::Output { FeeRate::from_sat_per_kwu(self.to_sat_per_kwu() + rhs.to_sat_per_kwu()) }
+        fn add(self, rhs: FeeRate) -> Self::Output { FeeRate::from_sat_per_mvb(self.to_sat_per_mvb() + rhs.to_sat_per_mvb()) }
     }
 
     impl ops::Sub<FeeRate> for FeeRate {
         type Output = FeeRate;
 
-        fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate::from_sat_per_kwu(self.to_sat_per_kwu() - rhs.to_sat_per_kwu()) }
+        fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate::from_sat_per_mvb(self.to_sat_per_mvb() - rhs.to_sat_per_mvb()) }
     }
 
     impl ops::Div<NonZeroU64> for FeeRate {
         type Output = FeeRate;
 
-        fn div(self, rhs: NonZeroU64) -> Self::Output{ Self::from_sat_per_kwu(self.to_sat_per_kwu() / rhs.get()) }
+        fn div(self, rhs: NonZeroU64) -> Self::Output{ Self::from_sat_per_mvb(self.to_sat_per_mvb() / rhs.get()) }
     }
 }
 crate::internal_macros::impl_add_assign!(FeeRate);
@@ -162,16 +246,16 @@ impl core::iter::Sum for FeeRate {
     where
         I: Iterator<Item = Self>,
     {
-        FeeRate::from_sat_per_kwu(iter.map(FeeRate::to_sat_per_kwu).sum())
+        Self::from_sat_per_mvb(iter.map(Self::to_sat_per_mvb).sum())
     }
 }
 
-impl<'a> core::iter::Sum<&'a FeeRate> for FeeRate {
+impl<'a> core::iter::Sum<&'a Self> for FeeRate {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a FeeRate>,
+        I: Iterator<Item = &'a Self>,
     {
-        FeeRate::from_sat_per_kwu(iter.map(|f| FeeRate::to_sat_per_kwu(*f)).sum())
+        Self::from_sat_per_mvb(iter.map(|f| Self::to_sat_per_mvb(*f)).sum())
     }
 }
 
@@ -180,11 +264,11 @@ impl<'a> Arbitrary<'a> for FeeRate {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=4)?;
         match choice {
-            0 => Ok(FeeRate::MIN),
-            1 => Ok(FeeRate::BROADCAST_MIN),
-            2 => Ok(FeeRate::DUST),
-            3 => Ok(FeeRate::MAX),
-            _ => Ok(FeeRate::from_sat_per_kwu(u64::arbitrary(u)?)),
+            0 => Ok(Self::MIN),
+            1 => Ok(Self::BROADCAST_MIN),
+            2 => Ok(Self::DUST),
+            3 => Ok(Self::MAX),
+            _ => Ok(Self::from_sat_per_mvb(u64::arbitrary(u)?)),
         }
     }
 }
@@ -195,12 +279,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn sanity_check() {
-        let fee_rate: u64 = u64::from(FeeRate::from_sat_per_kwu(100));
-        assert_eq!(fee_rate, 100_u64);
-    }
-
     #[test]
     #[allow(clippy::op_ref)]
     fn feerate_div_nonzero() {
@@ -245,6 +323,14 @@ mod tests {
         let mut f = FeeRate::from_sat_per_kwu(1);
         f += &FeeRate::from_sat_per_kwu(2);
         assert_eq!(f, FeeRate::from_sat_per_kwu(3));
+
+        let mut f = NumOpResult::Valid(FeeRate::from_sat_per_kwu(1));
+        f += FeeRate::from_sat_per_kwu(2);
+        assert_eq!(f, NumOpResult::Valid(FeeRate::from_sat_per_kwu(3)));
+
+        let mut f = NumOpResult::Valid(FeeRate::from_sat_per_kwu(1));
+        f += NumOpResult::Valid(FeeRate::from_sat_per_kwu(2));
+        assert_eq!(f, NumOpResult::Valid(FeeRate::from_sat_per_kwu(3)));
     }
 
     #[test]
@@ -256,77 +342,89 @@ mod tests {
         let mut f = FeeRate::from_sat_per_kwu(3);
         f -= &FeeRate::from_sat_per_kwu(2);
         assert_eq!(f, FeeRate::from_sat_per_kwu(1));
+
+        let mut f = NumOpResult::Valid(FeeRate::from_sat_per_kwu(3));
+        f -= FeeRate::from_sat_per_kwu(2);
+        assert_eq!(f, NumOpResult::Valid(FeeRate::from_sat_per_kwu(1)));
+
+        let mut f = NumOpResult::Valid(FeeRate::from_sat_per_kwu(3));
+        f -= NumOpResult::Valid(FeeRate::from_sat_per_kwu(2));
+        assert_eq!(f, NumOpResult::Valid(FeeRate::from_sat_per_kwu(1)));
     }
 
     #[test]
     fn checked_add() {
-        let f = FeeRate::from_sat_per_kwu(1).checked_add(2).unwrap();
-        assert_eq!(FeeRate::from_sat_per_kwu(3), f);
+        let one = FeeRate::from_sat_per_kwu(1);
+        let two = FeeRate::from_sat_per_kwu(2);
+        let three = FeeRate::from_sat_per_kwu(3);
 
-        let f = FeeRate::from_sat_per_kwu(u64::MAX).checked_add(1);
-        assert!(f.is_none());
+        assert_eq!(one.checked_add(two).unwrap(), three);
+
+        // Sanity check - no overflow adding one to per kvb max.
+        let _ = FeeRate::from_sat_per_kvb(u32::MAX).checked_add(one).unwrap();
+        let fee_rate = FeeRate::from_sat_per_mvb(u64::MAX).checked_add(one);
+        assert!(fee_rate.is_none());
     }
 
     #[test]
     fn checked_sub() {
-        let f = FeeRate::from_sat_per_kwu(2).checked_sub(1).unwrap();
-        assert_eq!(FeeRate::from_sat_per_kwu(1), f);
+        let one = FeeRate::from_sat_per_kwu(1);
+        let two = FeeRate::from_sat_per_kwu(2);
+        let three = FeeRate::from_sat_per_kwu(3);
+        assert_eq!(three.checked_sub(two).unwrap(), one);
 
-        let f = FeeRate::ZERO.checked_sub(1);
-        assert!(f.is_none());
+        let fee_rate = FeeRate::ZERO.checked_sub(one);
+        assert!(fee_rate.is_none());
     }
 
     #[test]
     fn fee_rate_const() {
-        assert_eq!(0, FeeRate::ZERO.to_sat_per_kwu());
-        assert_eq!(u64::MIN, FeeRate::MIN.to_sat_per_kwu());
-        assert_eq!(u64::MAX, FeeRate::MAX.to_sat_per_kwu());
-        assert_eq!(250, FeeRate::BROADCAST_MIN.to_sat_per_kwu());
-        assert_eq!(750, FeeRate::DUST.to_sat_per_kwu());
+        assert_eq!(FeeRate::ZERO.to_sat_per_kwu_floor(), 0);
+        assert_eq!(FeeRate::MIN.to_sat_per_kwu_floor(), u64::MIN);
+        assert_eq!(FeeRate::MAX.to_sat_per_kwu_floor(), u64::MAX / 4_000);
+        assert_eq!(FeeRate::BROADCAST_MIN.to_sat_per_kwu_floor(), 250);
+        assert_eq!(FeeRate::DUST.to_sat_per_kwu_floor(), 750);
     }
 
     #[test]
     fn fee_rate_from_sat_per_vb() {
-        let fee_rate = FeeRate::from_sat_per_vb(10).expect("expected feerate in sat/kwu");
-        assert_eq!(FeeRate::from_sat_per_kwu(2500), fee_rate);
+        let fee_rate = FeeRate::from_sat_per_vb(10);
+        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(2500));
     }
 
     #[test]
     fn fee_rate_from_sat_per_kvb() {
         let fee_rate = FeeRate::from_sat_per_kvb(11);
-        assert_eq!(FeeRate::from_sat_per_kwu(2), fee_rate);
+        assert_eq!(fee_rate, FeeRate::from_sat_per_mvb(11_000));
     }
 
     #[test]
-    fn fee_rate_from_sat_per_vb_overflow() {
-        let fee_rate = FeeRate::from_sat_per_vb(u64::MAX);
-        assert!(fee_rate.is_none());
-    }
+    fn fee_rate_to_sat_per_x() {
+        let fee_rate = FeeRate::from_sat_per_mvb(2_000_400);
 
-    #[test]
-    fn from_sat_per_vb_unchecked() {
-        let fee_rate = FeeRate::from_sat_per_vb_unchecked(10);
-        assert_eq!(FeeRate::from_sat_per_kwu(2500), fee_rate);
-    }
+        // sat/kwu: 2_000_400 / 4_000 = 500.1
+        assert_eq!(fee_rate.to_sat_per_kwu_floor(), 500);
+        assert_eq!(fee_rate.to_sat_per_kwu_ceil(), 501);
 
-    #[test]
-    #[cfg(debug_assertions)]
-    #[should_panic = "attempt to multiply with overflow"]
-    fn from_sat_per_vb_unchecked_panic() { FeeRate::from_sat_per_vb_unchecked(u64::MAX); }
+        // sat/vB: 2_000_400 / 1_000_000 = 2.0004
+        assert_eq!(fee_rate.to_sat_per_vb_floor(), 2);
+        assert_eq!(fee_rate.to_sat_per_vb_ceil(), 3);
 
-    #[test]
-    fn raw_feerate() {
-        let fee_rate = FeeRate::from_sat_per_kwu(749);
-        assert_eq!(749, fee_rate.to_sat_per_kwu());
-        assert_eq!(2, fee_rate.to_sat_per_vb_floor());
-        assert_eq!(3, fee_rate.to_sat_per_vb_ceil());
+        // sat/kvb: 2_000_400 / 1_000 = 2_000.4
+        assert_eq!(fee_rate.to_sat_per_kvb_floor(), 2_000);
+        assert_eq!(fee_rate.to_sat_per_kvb_ceil(), 2_001);
+
+        let max = FeeRate::MAX;
+        assert_eq!(max.to_sat_per_kwu_ceil(), u64::MAX / 4_000 + 1);
+        assert_eq!(max.to_sat_per_vb_ceil(), u64::MAX / 1_000_000 + 1);
+        assert_eq!(max.to_sat_per_kvb_ceil(), u64::MAX / 1_000 + 1);
     }
 
     #[test]
     fn checked_mul() {
         let fee_rate =
             FeeRate::from_sat_per_kwu(10).checked_mul(10).expect("expected feerate in sat/kwu");
-        assert_eq!(FeeRate::from_sat_per_kwu(100), fee_rate);
+        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(100));
 
         let fee_rate = FeeRate::from_sat_per_kwu(10).checked_mul(u64::MAX);
         assert!(fee_rate.is_none());
@@ -336,9 +434,16 @@ mod tests {
     fn checked_div() {
         let fee_rate =
             FeeRate::from_sat_per_kwu(10).checked_div(10).expect("expected feerate in sat/kwu");
-        assert_eq!(FeeRate::from_sat_per_kwu(1), fee_rate);
+        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
         let fee_rate = FeeRate::from_sat_per_kwu(10).checked_div(0);
         assert!(fee_rate.is_none());
     }
+
+    #[test]
+    fn mvb() {
+        let fee_rate = FeeRate::from_sat_per_mvb(1_234_567);
+        let got = fee_rate.to_sat_per_mvb();
+        assert_eq!(got, 1_234_567);
+    }
 }
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index ae2e2fb8f2..f778a73287 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -18,7 +18,7 @@
 //!
 //! #[derive(Serialize, Deserialize)]
 //! pub struct Foo {
-//!     #[serde(with = "fee_rate::serde::as_sat_per_kwu")]
+//!     #[serde(with = "fee_rate::serde::as_sat_per_kwu_floor")]
 //!     pub fee_rate: FeeRate,
 //! }
 //! ```
@@ -26,27 +26,32 @@
 use core::convert::Infallible;
 use core::fmt;
 
-pub mod as_sat_per_kwu {
+pub mod as_sat_per_kwu_floor {
     //! Serialize and deserialize [`FeeRate`] denominated in satoshis per 1000 weight units.
     //!
-    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu")]`.
+    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu_floor")]`.
 
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    use crate::FeeRate;
+    use crate::{Amount, FeeRate};
 
     pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
-        u64::serialize(&f.to_sat_per_kwu(), s)
+        u64::serialize(&f.to_sat_per_kwu_floor(), s)
     }
 
     pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
-        Ok(FeeRate::from_sat_per_kwu(u64::deserialize(d)?))
+        let sat = u64::deserialize(d)?;
+        FeeRate::from_per_kwu(
+            Amount::from_sat(sat).map_err(|_| serde::de::Error::custom("amount out of range"))?,
+        )
+        .into_result()
+        .map_err(|_| serde::de::Error::custom("fee rate too big for sats/kwu"))
     }
 
     pub mod opt {
         //! Serialize and deserialize [`Option<FeeRate>`] denominated in satoshis per 1000 weight units.
         //!
-        //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu::opt")]`.
+        //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu_floor::opt")]`.
 
         use core::fmt;
 
@@ -57,7 +62,7 @@ pub mod as_sat_per_kwu {
         #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
             match *f {
-                Some(f) => s.serialize_some(&f.to_sat_per_kwu()),
+                Some(f) => s.serialize_some(&f.to_sat_per_kwu_floor()),
                 None => s.serialize_none(),
             }
         }
@@ -99,8 +104,7 @@ pub mod as_sat_per_vb_floor {
 
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    use crate::fee_rate::serde::OverflowError;
-    use crate::fee_rate::FeeRate;
+    use crate::{Amount, FeeRate};
 
     pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
         u64::serialize(&f.to_sat_per_vb_floor(), s)
@@ -108,9 +112,12 @@ pub mod as_sat_per_vb_floor {
 
     // Errors on overflow.
     pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
-        FeeRate::from_sat_per_vb(u64::deserialize(d)?)
-            .ok_or(OverflowError)
-            .map_err(serde::de::Error::custom)
+        let sat = u64::deserialize(d)?;
+        FeeRate::from_per_vb(
+            Amount::from_sat(sat).map_err(|_| serde::de::Error::custom("amount out of range"))?,
+        )
+        .into_result()
+        .map_err(|_| serde::de::Error::custom("fee rate too big for sats/vb"))
     }
 
     pub mod opt {
@@ -170,8 +177,7 @@ pub mod as_sat_per_vb_ceil {
 
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    use crate::fee_rate::serde::OverflowError;
-    use crate::fee_rate::FeeRate;
+    use crate::{Amount, FeeRate};
 
     pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
         u64::serialize(&f.to_sat_per_vb_ceil(), s)
@@ -179,9 +185,12 @@ pub mod as_sat_per_vb_ceil {
 
     // Errors on overflow.
     pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
-        FeeRate::from_sat_per_vb(u64::deserialize(d)?)
-            .ok_or(OverflowError)
-            .map_err(serde::de::Error::custom)
+        let sat = u64::deserialize(d)?;
+        FeeRate::from_per_vb(
+            Amount::from_sat(sat).map_err(|_| serde::de::Error::custom("amount out of range"))?,
+        )
+        .into_result()
+        .map_err(|_| serde::de::Error::custom("fee rate too big for sats/vb"))
     }
 
     pub mod opt {
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index df8c565385..ac88c21801 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -83,6 +83,60 @@ macro_rules! impl_add_assign {
 }
 pub(crate) use impl_add_assign;
 
+/// Implement `ops::AddAssign` for `$ty` and `NumOpResult<$ty>` on `NumOpResult<$ty>`
+///
+/// This implements the same logic as the generic `NumOpResult` implementation in result.rs,
+/// but works for types that can't implement `AddAssign` on themselves (e.g. `Amount`, `SignedAmount`)
+macro_rules! impl_add_assign_for_results {
+    ($ty:ident) => {
+        impl ops::AddAssign<$ty> for NumOpResult<$ty> {
+            fn add_assign(&mut self, rhs: $ty) {
+                match self {
+                    Self::Error(_) => *self = Self::Error(NumOpError::while_doing(MathOp::Add)),
+                    Self::Valid(ref lhs) => *self = lhs + rhs,
+                }
+            }
+        }
+
+        impl ops::AddAssign<Self> for NumOpResult<$ty> {
+            fn add_assign(&mut self, rhs: Self) {
+                match (&self, rhs) {
+                    (Self::Valid(_), Self::Valid(rhs)) => *self += rhs,
+                    (_, _) => *self = Self::Error(NumOpError::while_doing(MathOp::Add)),
+                }
+            }
+        }
+    };
+}
+pub(crate) use impl_add_assign_for_results;
+
+/// Implement `ops::SubAssign` for `$ty` and `NumOpResult<$ty>` on `NumOpResult<$ty>`
+///
+/// This implements the same logic as the generic `NumOpResult` implementation in result.rs,
+/// but works for types that can't implement `SubAssign` on themselves (e.g. `Amount`, `SignedAmount`)
+macro_rules! impl_sub_assign_for_results {
+    ($ty:ident) => {
+        impl ops::SubAssign<$ty> for NumOpResult<$ty> {
+            fn sub_assign(&mut self, rhs: $ty) {
+                match self {
+                    Self::Error(_) => *self = Self::Error(NumOpError::while_doing(MathOp::Sub)),
+                    Self::Valid(ref lhs) => *self = lhs - rhs,
+                }
+            }
+        }
+
+        impl ops::SubAssign<Self> for NumOpResult<$ty> {
+            fn sub_assign(&mut self, rhs: Self) {
+                match (&self, rhs) {
+                    (Self::Valid(_), Self::Valid(rhs)) => *self -= rhs,
+                    (_, _) => *self = Self::Error(NumOpError::while_doing(MathOp::Sub)),
+                }
+            }
+        }
+    };
+}
+pub(crate) use impl_sub_assign_for_results;
+
 /// Implement `ops::SubAssign` for `$ty` and `&$ty`.
 macro_rules! impl_sub_assign {
     ($ty:ident) => {
diff --git a/units/src/lib.rs b/units/src/lib.rs
index 06d24d7188..960c8e0c78 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin - unit types
+//! Rust Bitcoin - unit types
 //!
 //! This library provides basic types used by the Rust Bitcoin ecosystem.
 //!
@@ -19,14 +19,14 @@
 //! ```
 
 #![no_std]
-// Experimental features we need.
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
 // Exclude lints we don't think are valuable.
-#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)`instead of enforcing `format!("{x}")`
+#![allow(clippy::uninlined_format_args)] // Allow `format!("{}", x)` instead of enforcing `format!("{x}")`
+// Extra restriction lints.
+#![warn(clippy::indexing_slicing)] // Avoid implicit panics from indexing/slicing.
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -34,10 +34,6 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
-mod fee;
-mod internal_macros;
-mod result;
-
 #[doc(hidden)]
 pub mod _export {
     /// A re-export of `core::*`.
@@ -46,11 +42,16 @@ pub mod _export {
     }
 }
 
+mod fee;
+mod internal_macros;
+
 pub mod amount;
 pub mod block;
 pub mod fee_rate;
 pub mod locktime;
-pub mod parse;
+pub mod parse_int;
+pub mod result;
+pub mod sequence;
 pub mod time;
 pub mod weight;
 
@@ -60,12 +61,13 @@ pub use self::{
     amount::{Amount, SignedAmount},
     block::{BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval},
     fee_rate::FeeRate,
-    result::{NumOpError, NumOpResult, MathOp},
+    locktime::{absolute, relative},
+    result::NumOpResult,
+    sequence::Sequence,
     time::BlockTime,
     weight::Weight
 };
-pub(crate) use self::result::OptionExt;
 
-#[deprecated(since = "TBD", note = "use `BlockHeightInterval` instead")]
+#[deprecated(since = "1.0.0-rc.0", note = "use `BlockHeightInterval` instead")]
 #[doc(hidden)]
 pub type BlockInterval = BlockHeightInterval;
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
deleted file mode 100644
index f80ccdfee2..0000000000
--- a/units/src/locktime/absolute.rs
+++ /dev/null
@@ -1,591 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Provides [`Height`] and [`MedianTimePast`] types used by the `rust-bitcoin` `absolute::LockTime` type.
-
-use core::convert::Infallible;
-use core::fmt;
-
-#[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
-use internals::error::InputString;
-
-use crate::parse::{self, ParseIntError};
-
-/// The Threshold for deciding whether a lock time value is a height or a time (see [Bitcoin Core]).
-///
-/// `LockTime` values _below_ the threshold are interpreted as block heights, values _above_ (or
-/// equal to) the threshold are interpreted as block times (UNIX timestamp, seconds since epoch).
-///
-/// Bitcoin is able to safely use this value because a block height greater than 500,000,000 would
-/// never occur because it would represent a height in approximately 9500 years. Conversely, block
-/// times under 500,000,000 will never happen because they would represent times before 1986 which
-/// are, for obvious reasons, not useful within the Bitcoin network.
-///
-/// [Bitcoin Core]: https://github.com/bitcoin/bitcoin/blob/9ccaee1d5e2e4b79b0a7c29aadb41b97e4741332/src/script/script.h#L39
-pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
-
-/// An absolute block height, guaranteed to always contain a valid height value.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Height(u32);
-
-impl Height {
-    /// Absolute block height 0, the genesis block.
-    pub const ZERO: Self = Height(0);
-
-    /// The minimum absolute block height (0), the genesis block.
-    pub const MIN: Self = Self::ZERO;
-
-    /// The maximum absolute block height.
-    pub const MAX: Self = Height(LOCK_TIME_THRESHOLD - 1);
-
-    /// Constructs a new [`Height`] from a hex string.
-    ///
-    /// The input string may or may not contain a typical hex prefix e.g., `0x`.
-    ///
-    /// # Errors
-    ///
-    /// If the input string is not a valid hex representation of a block height.
-    pub fn from_hex(s: &str) -> Result<Self, ParseHeightError> { parse_hex(s, Self::from_u32) }
-
-    #[deprecated(since = "TBD", note = "use `from_u32` instead")]
-    #[doc(hidden)]
-    pub const fn from_consensus(n: u32) -> Result<Self, ConversionError> { Self::from_u32(n) }
-
-    #[deprecated(since = "TBD", note = "use `to_u32` instead")]
-    #[doc(hidden)]
-    pub const fn to_consensus_u32(self) -> u32 { self.to_u32() }
-
-    /// Constructs a new block height directly from a `u32` value.
-    ///
-    /// # Errors
-    ///
-    /// If `n` does not represent a block height within the valid range for a locktime:
-    /// `[0, 499_999_999]`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin_units::locktime::absolute::Height;
-    ///
-    /// let h: u32 = 741521;
-    /// let height = Height::from_u32(h).expect("invalid height value");
-    /// assert_eq!(height.to_consensus_u32(), h);
-    /// ```
-    #[inline]
-    pub const fn from_u32(n: u32) -> Result<Height, ConversionError> {
-        if is_block_height(n) {
-            Ok(Self(n))
-        } else {
-            Err(ConversionError::invalid_height(n))
-        }
-    }
-
-    /// Converts this [`Height`] to a raw `u32` value.
-    #[inline]
-    pub const fn to_u32(self) -> u32 { self.0 }
-}
-
-impl fmt::Display for Height {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
-}
-
-crate::impl_parse_str!(Height, ParseHeightError, parser(Height::from_u32));
-
-/// Error returned when parsing block height fails.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ParseHeightError(ParseError);
-
-impl fmt::Display for ParseHeightError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.display(f, "block height", 0, LOCK_TIME_THRESHOLD - 1)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ParseHeightError {
-    // To be consistent with `write_err` we need to **not** return source in case of overflow
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { self.0.source() }
-}
-
-impl From<ParseError> for ParseHeightError {
-    fn from(value: ParseError) -> Self { Self(value) }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for Height {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let u = u32::deserialize(deserializer)?;
-        Height::from_u32(u).map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Height {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.to_u32().serialize(serializer)
-    }
-}
-
-#[deprecated(since = "TBD", note = "use `MedianTimePast` instead")]
-#[doc(hidden)]
-pub type Time = MedianTimePast;
-
-/// The median timestamp of 11 consecutive blocks, representing "the timestamp" of the
-/// final block for locktime-checking purposes.
-///
-/// Time-based locktimes are not measured against the timestamps in individual block
-/// headers, since these are not monotone and may be subject to miner manipulation.
-/// Instead, locktimes use the "median-time-past" (MTP) of the most recent 11 blocks,
-/// a quantity which is required by consensus to be monotone and which is difficult
-/// for any individual miner to manipulate.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct MedianTimePast(u32);
-
-impl MedianTimePast {
-    /// The minimum MTP allowable in a locktime (Tue Nov 05 1985 00:53:20 GMT+0000).
-    pub const MIN: Self = MedianTimePast(LOCK_TIME_THRESHOLD);
-
-    /// The maximum MTP allowable in a locktime (Sun Feb 07 2106 06:28:15 GMT+0000).
-    pub const MAX: Self = MedianTimePast(u32::MAX);
-
-    /// Constructs an [`MedianTimePast`] by computing the median‐time‐past from the last 11 block timestamps
-    ///
-    /// Because block timestamps are not monotonic, this function internally sorts them;
-    /// it is therefore not important what order they appear in the array; use whatever
-    /// is most convenient.
-    ///
-    /// # Errors
-    ///
-    /// If the median block timestamp is not in the allowable range of MTPs in a
-    /// locktime: `[500_000_000, 2^32 - 1]`. Because there is a consensus rule that MTP
-    /// be monotonically increasing, and the MTP of the first 11 blocks exceeds `500_000_000`
-    /// for every real-life chain, this error typically cannot be hit in practice.
-    pub fn new(timestamps: [crate::BlockTime; 11]) -> Result<Self, ConversionError> {
-        crate::BlockMtp::new(timestamps).try_into()
-    }
-
-    /// Constructs a new [`MedianTimePast`] from a big-endian hex-encoded `u32`.
-    ///
-    /// The input string may or may not contain a typical hex prefix e.g., `0x`.
-    ///
-    /// # Errors
-    ///
-    /// If the input string is not a valid hex representation of a block time.
-    pub fn from_hex(s: &str) -> Result<Self, ParseTimeError> { parse_hex(s, Self::from_u32) }
-
-    #[deprecated(since = "TBD", note = "use `from_u32` instead")]
-    #[doc(hidden)]
-    pub const fn from_consensus(n: u32) -> Result<Self, ConversionError> { Self::from_u32(n) }
-
-    #[deprecated(since = "TBD", note = "use `to_u32` instead")]
-    #[doc(hidden)]
-    pub const fn to_consensus_u32(self) -> u32 { self.to_u32() }
-
-    /// Constructs a new MTP directly from a `u32` value.
-    ///
-    /// This function, with [`MedianTimePast::to_u32`], is used to obtain a raw MTP value. It is
-    /// **not** used to convert to or from a block timestamp, which is not a MTP.
-    ///
-    /// # Errors
-    ///
-    /// If `n` is not in the allowable range of MTPs in a locktime: `[500_000_000, 2^32 - 1]`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin_units::locktime::absolute::MedianTimePast;
-    ///
-    /// let t: u32 = 1653195600; // May 22nd, 5am UTC.
-    /// let time = MedianTimePast::from_u32(t).expect("invalid time value");
-    /// assert_eq!(time.to_consensus_u32(), t);
-    /// ```
-    #[inline]
-    pub const fn from_u32(n: u32) -> Result<Self, ConversionError> {
-        if is_block_time(n) {
-            Ok(Self(n))
-        } else {
-            Err(ConversionError::invalid_time(n))
-        }
-    }
-
-    /// Converts this [`MedianTimePast`] to a raw `u32` value.
-    #[inline]
-    pub const fn to_u32(self) -> u32 { self.0 }
-}
-
-impl fmt::Display for MedianTimePast {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
-}
-
-crate::impl_parse_str!(MedianTimePast, ParseTimeError, parser(MedianTimePast::from_u32));
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for MedianTimePast {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let u = u32::deserialize(deserializer)?;
-        MedianTimePast::from_u32(u).map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for MedianTimePast {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.to_u32().serialize(serializer)
-    }
-}
-
-/// Error returned when parsing block time fails.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ParseTimeError(ParseError);
-
-impl fmt::Display for ParseTimeError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.display(f, "block time", LOCK_TIME_THRESHOLD, u32::MAX)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ParseTimeError {
-    // To be consistent with `write_err` we need to **not** return source in case of overflow
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { self.0.source() }
-}
-
-impl From<ParseError> for ParseTimeError {
-    fn from(value: ParseError) -> Self { Self(value) }
-}
-
-fn parser<T, E, S, F>(f: F) -> impl FnOnce(S) -> Result<T, E>
-where
-    E: From<ParseError>,
-    S: AsRef<str> + Into<InputString>,
-    F: FnOnce(u32) -> Result<T, ConversionError>,
-{
-    move |s| {
-        let n = s.as_ref().parse::<i64>().map_err(ParseError::invalid_int(s))?;
-        let n = u32::try_from(n).map_err(|_| ParseError::Conversion(n))?;
-        f(n).map_err(ParseError::from).map_err(Into::into)
-    }
-}
-
-fn parse_hex<T, E, S, F>(s: S, f: F) -> Result<T, E>
-where
-    E: From<ParseError>,
-    S: AsRef<str> + Into<InputString>,
-    F: FnOnce(u32) -> Result<T, ConversionError>,
-{
-    let n = i64::from_str_radix(parse::hex_remove_optional_prefix(s.as_ref()), 16)
-        .map_err(ParseError::invalid_int(s))?;
-    let n = u32::try_from(n).map_err(|_| ParseError::Conversion(n))?;
-    f(n).map_err(ParseError::from).map_err(Into::into)
-}
-
-/// Returns true if `n` is a block height i.e., less than 500,000,000.
-pub const fn is_block_height(n: u32) -> bool { n < LOCK_TIME_THRESHOLD }
-
-/// Returns true if `n` is a UNIX timestamp i.e., greater than or equal to 500,000,000.
-pub const fn is_block_time(n: u32) -> bool { n >= LOCK_TIME_THRESHOLD }
-
-/// Error returned when converting a `u32` to a lock time variant fails.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub struct ConversionError {
-    /// The expected timelock unit, height (blocks) or time (seconds).
-    unit: LockTimeUnit,
-    /// The invalid input value.
-    input: u32,
-}
-
-impl ConversionError {
-    /// Constructs a new `ConversionError` from an invalid `n` when expecting a height value.
-    const fn invalid_height(n: u32) -> Self { Self { unit: LockTimeUnit::Blocks, input: n } }
-
-    /// Constructs a new `ConversionError` from an invalid `n` when expecting a time value.
-    const fn invalid_time(n: u32) -> Self { Self { unit: LockTimeUnit::Seconds, input: n } }
-}
-
-impl fmt::Display for ConversionError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "invalid lock time value {}, {}", self.input, self.unit)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ConversionError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
-}
-
-/// Describes the two types of locking, lock-by-blockheight and lock-by-blocktime.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-enum LockTimeUnit {
-    /// Lock by blockheight.
-    Blocks,
-    /// Lock by blocktime.
-    Seconds,
-}
-
-impl fmt::Display for LockTimeUnit {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTimeUnit as L;
-
-        match *self {
-            L::Blocks =>
-                write!(f, "expected lock-by-blockheight (must be < {})", LOCK_TIME_THRESHOLD),
-            L::Seconds =>
-                write!(f, "expected lock-by-blocktime (must be >= {})", LOCK_TIME_THRESHOLD),
-        }
-    }
-}
-
-/// Internal - common representation for height and time.
-#[derive(Debug, Clone, Eq, PartialEq)]
-enum ParseError {
-    ParseInt(ParseIntError),
-    // unit implied by outer type
-    // we use i64 to have nicer messages for negative values
-    Conversion(i64),
-}
-
-impl From<Infallible> for ParseError {
-    fn from(never: Infallible) -> Self { match never {} }
-}
-
-impl ParseError {
-    fn invalid_int<S: Into<InputString>>(s: S) -> impl FnOnce(core::num::ParseIntError) -> Self {
-        move |source| {
-            Self::ParseInt(ParseIntError { input: s.into(), bits: 32, is_signed: true, source })
-        }
-    }
-
-    fn display(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        subject: &str,
-        lower_bound: u32,
-        upper_bound: u32,
-    ) -> fmt::Result {
-        use core::num::IntErrorKind;
-
-        use ParseError as E;
-
-        match self {
-            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
-                if *source.kind() == IntErrorKind::PosOverflow =>
-            {
-                // Outputs "failed to parse <input_string> as absolute Height/MedianTimePast (<subject> is above limit <upper_bound>)"
-                write!(
-                    f,
-                    "{} ({} is above limit {})",
-                    input.display_cannot_parse("absolute Height/MedianTimePast"),
-                    subject,
-                    upper_bound
-                )
-            }
-            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
-                if *source.kind() == IntErrorKind::NegOverflow =>
-            {
-                // Outputs "failed to parse <input_string> as absolute Height/MedianTimePast (<subject> is below limit <lower_bound>)"
-                write!(
-                    f,
-                    "{} ({} is below limit {})",
-                    input.display_cannot_parse("absolute Height/MedianTimePast"),
-                    subject,
-                    lower_bound
-                )
-            }
-            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source: _ }) => {
-                write!(
-                    f,
-                    "{} ({})",
-                    input.display_cannot_parse("absolute Height/MedianTimePast"),
-                    subject
-                )
-            }
-            E::Conversion(value) if *value < i64::from(lower_bound) => {
-                write!(f, "{} {} is below limit {}", subject, value, lower_bound)
-            }
-            E::Conversion(value) => {
-                write!(f, "{} {} is above limit {}", subject, value, upper_bound)
-            }
-        }
-    }
-
-    // To be consistent with `write_err` we need to **not** return source in case of overflow
-    #[cfg(feature = "std")]
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use core::num::IntErrorKind;
-
-        use ParseError as E;
-
-        match self {
-            E::ParseInt(ParseIntError { source, .. })
-                if *source.kind() == IntErrorKind::PosOverflow =>
-                None,
-            E::ParseInt(ParseIntError { source, .. })
-                if *source.kind() == IntErrorKind::NegOverflow =>
-                None,
-            E::ParseInt(ParseIntError { source, .. }) => Some(source),
-            E::Conversion(_) => None,
-        }
-    }
-}
-
-impl From<ConversionError> for ParseError {
-    fn from(value: ConversionError) -> Self { Self::Conversion(value.input.into()) }
-}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for Height {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let choice = u.int_in_range(0..=2)?;
-        match choice {
-            0 => Ok(Height::MIN),
-            1 => Ok(Height::MAX),
-            _ => {
-                let min = Height::MIN.to_u32();
-                let max = Height::MAX.to_u32();
-                let h = u.int_in_range(min..=max)?;
-                Ok(Height::from_u32(h).unwrap())
-            }
-        }
-    }
-}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for MedianTimePast {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let choice = u.int_in_range(0..=2)?;
-        match choice {
-            0 => Ok(MedianTimePast::MIN),
-            1 => Ok(MedianTimePast::MAX),
-            _ => {
-                let min = MedianTimePast::MIN.to_u32();
-                let max = MedianTimePast::MAX.to_u32();
-                let t = u.int_in_range(min..=max)?;
-                Ok(MedianTimePast::from_u32(t).unwrap())
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[cfg(feature = "serde")]
-    use internals::serde_round_trip;
-
-    use super::*;
-
-    #[test]
-    fn time_from_str_hex_happy_path() {
-        let actual = MedianTimePast::from_hex("0x6289C350").unwrap();
-        let expected = MedianTimePast::from_u32(0x6289_C350).unwrap();
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn time_from_str_hex_no_prefix_happy_path() {
-        let time = MedianTimePast::from_hex("6289C350").unwrap();
-        assert_eq!(time, MedianTimePast(0x6289_C350));
-    }
-
-    #[test]
-    fn time_from_str_hex_invalid_hex_should_err() {
-        let hex = "0xzb93";
-        let result = MedianTimePast::from_hex(hex);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn height_from_str_hex_happy_path() {
-        let actual = Height::from_hex("0xBA70D").unwrap();
-        let expected = Height(0xBA70D);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn height_from_str_hex_no_prefix_happy_path() {
-        let height = Height::from_hex("BA70D").unwrap();
-        assert_eq!(height, Height(0xBA70D));
-    }
-
-    #[test]
-    fn height_from_str_hex_invalid_hex_should_err() {
-        let hex = "0xzb93";
-        let result = Height::from_hex(hex);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn is_block_height_or_time() {
-        assert!(is_block_height(499_999_999));
-        assert!(!is_block_height(500_000_000));
-
-        assert!(!is_block_time(499_999_999));
-        assert!(is_block_time(500_000_000));
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_decode_height() {
-        serde_round_trip!(Height::ZERO);
-        serde_round_trip!(Height::MIN);
-        serde_round_trip!(Height::MAX);
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_decode_time() {
-        serde_round_trip!(MedianTimePast::MIN);
-        serde_round_trip!(MedianTimePast::MAX);
-    }
-
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn locktime_unit_display() {
-        use alloc::format;
-        let blocks = LockTimeUnit::Blocks;
-        let seconds = LockTimeUnit::Seconds;
-
-        assert_eq!(format!("{}", blocks), "expected lock-by-blockheight (must be < 500000000)");
-        assert_eq!(format!("{}", seconds), "expected lock-by-blocktime (must be >= 500000000)");
-    }
-
-    #[test]
-    fn valid_chain_computes_mtp() {
-        use crate::BlockTime;
-
-        let mut timestamps = [
-            BlockTime::from_u32(500_000_010),
-            BlockTime::from_u32(500_000_003),
-            BlockTime::from_u32(500_000_005),
-            BlockTime::from_u32(500_000_008),
-            BlockTime::from_u32(500_000_001),
-            BlockTime::from_u32(500_000_004),
-            BlockTime::from_u32(500_000_006),
-            BlockTime::from_u32(500_000_009),
-            BlockTime::from_u32(500_000_002),
-            BlockTime::from_u32(500_000_007),
-            BlockTime::from_u32(500_000_000),
-        ];
-
-        // Try various reorderings
-        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
-        timestamps.reverse();
-        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
-        timestamps.sort();
-        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
-        timestamps.reverse();
-        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
-    }
-}
diff --git a/units/src/locktime/absolute/error.rs b/units/src/locktime/absolute/error.rs
new file mode 100644
index 0000000000..c16480da77
--- /dev/null
+++ b/units/src/locktime/absolute/error.rs
@@ -0,0 +1,302 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Error types for the absolute locktime module.
+
+use core::convert::Infallible;
+use core::fmt;
+
+use internals::error::InputString;
+#[cfg(feature = "encoding")]
+use internals::write_err;
+
+use super::{Height, MedianTimePast, LOCK_TIME_THRESHOLD};
+use crate::parse_int::ParseIntError;
+
+/// An error consensus decoding an `LockTime`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LockTimeDecoderError(pub(super) encoding::UnexpectedEofError);
+
+#[cfg(feature = "encoding")]
+impl From<Infallible> for LockTimeDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "encoding")]
+impl fmt::Display for LockTimeDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "lock time decoder error"; self.0)
+    }
+}
+
+#[cfg(all(feature = "std", feature = "encoding"))]
+impl std::error::Error for LockTimeDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+/// Tried to satisfy a lock-by-time lock using a height value.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IncompatibleHeightError {
+    /// The inner value of the lock-by-time lock.
+    pub(super) lock: MedianTimePast,
+    /// Attempted to satisfy a lock-by-time lock with this height.
+    pub(super) incompatible: Height,
+}
+
+impl IncompatibleHeightError {
+    /// Returns the value of the lock-by-time lock.
+    pub fn lock(&self) -> MedianTimePast { self.lock }
+
+    /// Returns the height that was erroneously used to try and satisfy a lock-by-time lock.
+    pub fn incompatible(&self) -> Height { self.incompatible }
+}
+
+impl fmt::Display for IncompatibleHeightError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "tried to satisfy a lock-by-time lock {} with height: {}",
+            self.lock, self.incompatible
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IncompatibleHeightError {}
+
+/// Tried to satisfy a lock-by-height lock using a height value.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IncompatibleTimeError {
+    /// The inner value of the lock-by-height lock.
+    pub(super) lock: Height,
+    /// Attempted to satisfy a lock-by-height lock with this MTP.
+    pub(super) incompatible: MedianTimePast,
+}
+
+impl IncompatibleTimeError {
+    /// Returns the value of the lock-by-height lock.
+    pub fn lock(&self) -> Height { self.lock }
+
+    /// Returns the MTP that was erroneously used to try and satisfy a lock-by-height lock.
+    pub fn incompatible(&self) -> MedianTimePast { self.incompatible }
+}
+
+impl fmt::Display for IncompatibleTimeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "tried to satisfy a lock-by-height lock {} with MTP: {}",
+            self.lock, self.incompatible
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IncompatibleTimeError {}
+
+/// Error returned when parsing block height fails.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ParseHeightError(ParseError);
+
+impl fmt::Display for ParseHeightError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.display(f, "block height", 0, LOCK_TIME_THRESHOLD - 1)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseHeightError {
+    // To be consistent with `write_err` we need to **not** return source if overflow occurred
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { self.0.source() }
+}
+
+impl From<ParseError> for ParseHeightError {
+    fn from(value: ParseError) -> Self { Self(value) }
+}
+
+/// Error returned when parsing block time fails.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ParseTimeError(ParseError);
+
+impl fmt::Display for ParseTimeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.display(f, "block time", LOCK_TIME_THRESHOLD, u32::MAX)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseTimeError {
+    // To be consistent with `write_err` we need to **not** return source if overflow occurred
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { self.0.source() }
+}
+
+impl From<ParseError> for ParseTimeError {
+    fn from(value: ParseError) -> Self { Self(value) }
+}
+
+/// Internal - common representation for height and time.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub(super) enum ParseError {
+    ParseInt(ParseIntError),
+    // unit implied by outer type
+    // we use i64 to have nicer messages for negative values
+    Conversion(i64),
+}
+
+impl From<Infallible> for ParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl ParseError {
+    pub(super) fn invalid_int<S: Into<InputString>>(
+        s: S,
+    ) -> impl FnOnce(core::num::ParseIntError) -> Self {
+        move |source| {
+            Self::ParseInt(ParseIntError { input: s.into(), bits: 32, is_signed: true, source })
+        }
+    }
+
+    pub(super) fn display(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        subject: &str,
+        lower_bound: u32,
+        upper_bound: u32,
+    ) -> fmt::Result {
+        use core::num::IntErrorKind;
+
+        match self {
+            Self::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
+                if *source.kind() == IntErrorKind::PosOverflow =>
+            {
+                // Outputs "failed to parse <input_string> as absolute Height/MedianTimePast (<subject> is above limit <upper_bound>)"
+                write!(
+                    f,
+                    "{} ({} is above limit {})",
+                    input.display_cannot_parse("absolute Height/MedianTimePast"),
+                    subject,
+                    upper_bound
+                )
+            }
+            Self::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
+                if *source.kind() == IntErrorKind::NegOverflow =>
+            {
+                // Outputs "failed to parse <input_string> as absolute Height/MedianTimePast (<subject> is below limit <lower_bound>)"
+                write!(
+                    f,
+                    "{} ({} is below limit {})",
+                    input.display_cannot_parse("absolute Height/MedianTimePast"),
+                    subject,
+                    lower_bound
+                )
+            }
+            Self::ParseInt(ParseIntError { input, bits: _, is_signed: _, source: _ }) => {
+                write!(
+                    f,
+                    "{} ({})",
+                    input.display_cannot_parse("absolute Height/MedianTimePast"),
+                    subject
+                )
+            }
+            Self::Conversion(value) if *value < i64::from(lower_bound) => {
+                write!(f, "{} {} is below limit {}", subject, value, lower_bound)
+            }
+            Self::Conversion(value) => {
+                write!(f, "{} {} is above limit {}", subject, value, upper_bound)
+            }
+        }
+    }
+
+    // To be consistent with `write_err` we need to **not** return source if overflow occurred
+    #[cfg(feature = "std")]
+    pub(super) fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use core::num::IntErrorKind;
+
+        match self {
+            Self::ParseInt(ParseIntError { source, .. })
+                if *source.kind() == IntErrorKind::PosOverflow =>
+                None,
+            Self::ParseInt(ParseIntError { source, .. })
+                if *source.kind() == IntErrorKind::NegOverflow =>
+                None,
+            Self::ParseInt(ParseIntError { source, .. }) => Some(source),
+            Self::Conversion(_) => None,
+        }
+    }
+}
+
+impl From<ConversionError> for ParseError {
+    fn from(value: ConversionError) -> Self { Self::Conversion(value.input.into()) }
+}
+
+/// Error returned when converting a `u32` to a lock time variant fails.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConversionError {
+    /// The expected timelock unit, height (blocks) or time (seconds).
+    unit: LockTimeUnit,
+    /// The invalid input value.
+    input: u32,
+}
+
+impl ConversionError {
+    /// Constructs a new `ConversionError` from an invalid `n` when expecting a height value.
+    pub(super) const fn invalid_height(n: u32) -> Self {
+        Self { unit: LockTimeUnit::Blocks, input: n }
+    }
+
+    /// Constructs a new `ConversionError` from an invalid `n` when expecting a time value.
+    pub(super) const fn invalid_time(n: u32) -> Self {
+        Self { unit: LockTimeUnit::Seconds, input: n }
+    }
+}
+
+impl fmt::Display for ConversionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid lock time value {}, {}", self.input, self.unit)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ConversionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// Describes the two types of locking, lock-by-height and lock-by-time.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+enum LockTimeUnit {
+    /// Lock by blockheight.
+    Blocks,
+    /// Lock by blocktime.
+    Seconds,
+}
+
+impl fmt::Display for LockTimeUnit {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Blocks =>
+                write!(f, "expected lock-by-height (must be < {})", LOCK_TIME_THRESHOLD),
+            Self::Seconds =>
+                write!(f, "expected lock-by-time (must be >= {})", LOCK_TIME_THRESHOLD),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn locktime_unit_display() {
+        use alloc::format;
+
+        use super::LockTimeUnit;
+
+        let blocks = LockTimeUnit::Blocks;
+        let seconds = LockTimeUnit::Seconds;
+
+        assert_eq!(format!("{}", blocks), "expected lock-by-height (must be < 500000000)");
+        assert_eq!(format!("{}", seconds), "expected lock-by-time (must be >= 500000000)");
+    }
+}
diff --git a/units/src/locktime/absolute/mod.rs b/units/src/locktime/absolute/mod.rs
new file mode 100644
index 0000000000..06b39a1370
--- /dev/null
+++ b/units/src/locktime/absolute/mod.rs
@@ -0,0 +1,1042 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides type [`LockTime`] that implements the logic around `nLockTime`/`OP_CHECKLOCKTIMEVERIFY`.
+//!
+//! There are two types of lock time: lock-by-height and lock-by-time, distinguished by
+//! whether `LockTime < LOCKTIME_THRESHOLD`. To support these we provide the [`Height`] and
+//! [`MedianTimePast`] types.
+
+pub mod error;
+
+use core::fmt;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use internals::error::InputString;
+
+use self::error::ParseError;
+#[cfg(doc)]
+use crate::absolute;
+use crate::parse_int::{self, PrefixedHexError, UnprefixedHexError};
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(no_inline)]
+pub use self::error::{
+    ConversionError, IncompatibleHeightError, IncompatibleTimeError, ParseHeightError, ParseTimeError,
+};
+#[cfg(feature = "encoding")]
+pub use self::error::LockTimeDecoderError;
+
+/// The Threshold for deciding whether a lock time value is a height or a time (see [Bitcoin Core]).
+///
+/// `LockTime` values _below_ the threshold are interpreted as block heights, values _above_ (or
+/// equal to) the threshold are interpreted as block times (UNIX timestamp, seconds since epoch).
+///
+/// Bitcoin is able to safely use this value because a block height greater than 500,000,000 would
+/// never occur because it would represent a height in approximately 9500 years. Conversely, block
+/// times under 500,000,000 will never happen because they would represent times before 1986 which
+/// are, for obvious reasons, not useful within the Bitcoin network.
+///
+/// [Bitcoin Core]: https://github.com/bitcoin/bitcoin/blob/9ccaee1d5e2e4b79b0a7c29aadb41b97e4741332/src/script/script.h#L39
+pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
+
+/// An absolute lock time value, representing either a block height or a UNIX timestamp (seconds
+/// since epoch).
+///
+/// Used for transaction lock time (`nLockTime` in Bitcoin Core and `Transaction::lock_time`
+/// in `rust-bitcoin`) and also for the argument to opcode `OP_CHECKLOCKTIMEVERIFY`.
+///
+/// # Note on ordering
+///
+/// Locktimes may be height- or time-based, and these metrics are incommensurate; there is no total
+/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
+/// [`LockTime::is_satisfied_by`] API.
+///
+/// For transaction, which has a locktime field, we implement a total ordering to make
+/// it easy to store transactions in sorted data structures, and use the locktime's 32-bit integer
+/// consensus encoding to order it.
+///
+/// # Relevant BIPs
+///
+/// * [BIP-0065 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+/// * [BIP-0113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
+///
+/// # Examples
+///
+/// ```
+/// use bitcoin_units::absolute::{self, LockTime as L};
+/// # let n = absolute::LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
+/// # let lock_time = absolute::LockTime::from_consensus(741521);  // nLockTime
+/// // To compare absolute lock times there are various `is_satisfied_*` methods, you may also use:
+/// let _is_satisfied = match (n, lock_time) {
+///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
+///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
+///     _ => panic!("handle invalid comparison error"),
+/// };
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LockTime {
+    /// A block height lock time value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::absolute;
+    ///
+    /// let block: u32 = 741521;
+    /// let n = absolute::LockTime::from_height(block).expect("valid height");
+    /// assert!(n.is_block_height());
+    /// assert_eq!(n.to_consensus_u32(), block);
+    /// ```
+    Blocks(Height),
+    /// A UNIX timestamp lock time value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::absolute;
+    ///
+    /// let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
+    /// let n = absolute::LockTime::from_mtp(seconds).expect("valid time");
+    /// assert!(n.is_block_time());
+    /// assert_eq!(n.to_consensus_u32(), seconds);
+    /// ```
+    Seconds(MedianTimePast),
+}
+
+impl LockTime {
+    /// If transaction lock time is set to zero it is ignored, in other words a
+    /// transaction with nLocktime==0 is able to be included immediately in any block.
+    pub const ZERO: Self = Self::Blocks(Height::ZERO);
+
+    /// The number of bytes that the locktime contributes to the size of a transaction.
+    pub const SIZE: usize = 4; // Serialized length of a u32.
+
+    /// Constructs a new `LockTime` from a prefixed hex string.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a locktime or it does not include
+    /// the `0x` prefix.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{absolute, parse_int};
+    /// let hex_str = "0x61cf9980"; // Unix timestamp for January 1, 2022
+    /// let lock_time = absolute::LockTime::from_hex(hex_str)?;
+    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
+    ///
+    /// # Ok::<_, parse_int::PrefixedHexError>(())
+    /// ```
+    #[inline]
+    pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
+        let lock_time = parse_int::hex_u32_prefixed(s)?;
+        Ok(Self::from_consensus(lock_time))
+    }
+
+    /// Constructs a new `LockTime` from an unprefixed hex string.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a locktime or if it includes the
+    /// `0x` prefix.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{absolute, parse_int};
+    /// let hex_str = "61cf9980"; // Unix timestamp for January 1, 2022
+    /// let lock_time = absolute::LockTime::from_unprefixed_hex(hex_str)?;
+    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
+    ///
+    /// # Ok::<_, parse_int::UnprefixedHexError>(())
+    /// ```
+    #[inline]
+    pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
+        let lock_time = parse_int::hex_u32_unprefixed(s)?;
+        Ok(Self::from_consensus(lock_time))
+    }
+
+    /// Constructs a new `LockTime` from an `nLockTime` value or the argument to `OP_CHECKLOCKTIMEVERIFY`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::absolute;
+    ///
+    /// // `from_consensus` roundtrips as expected with `to_consensus_u32`.
+    /// let n_lock_time: u32 = 741521;
+    /// let lock_time = absolute::LockTime::from_consensus(n_lock_time);
+    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
+    #[inline]
+    #[allow(clippy::missing_panics_doc)]
+    pub fn from_consensus(n: u32) -> Self {
+        if crate::locktime::absolute::is_block_height(n) {
+            Self::Blocks(Height::from_u32(n).expect("n is valid"))
+        } else {
+            Self::Seconds(MedianTimePast::from_u32(n).expect("n is valid"))
+        }
+    }
+
+    /// Constructs a new `LockTime` from `n`, expecting `n` to be a valid block height.
+    ///
+    /// # Note
+    ///
+    /// If the current block height is `h` and the locktime is set to `h`,
+    /// the transaction can be included in block `h+1` or later.
+    /// It is possible to broadcast the transaction at block height `h`.
+    ///
+    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid height value.
+    ///
+    /// # Errors
+    ///
+    /// If `n` does not represent a block height within the valid range for a locktime:
+    /// `[0, 499_999_999]`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::absolute;
+    /// assert!(absolute::LockTime::from_height(741521).is_ok());
+    /// assert!(absolute::LockTime::from_height(1653195600).is_err());
+    /// ```
+    #[inline]
+    pub fn from_height(n: u32) -> Result<Self, ConversionError> {
+        let height = Height::from_u32(n)?;
+        Ok(Self::Blocks(height))
+    }
+
+    #[inline]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `from_mtp` instead")]
+    #[doc(hidden)]
+    pub fn from_time(n: u32) -> Result<Self, ConversionError> { Self::from_mtp(n) }
+
+    /// Constructs a new `LockTime` from `n`, expecting `n` to be a median-time-past (MTP)
+    /// which is in range for a locktime.
+    ///
+    /// # Note
+    ///
+    /// If the locktime is set to an MTP `T`, the transaction can be included in a block only if
+    /// the MTP of last recent 11 blocks is greater than `T`.
+    ///
+    /// It is possible to broadcast the transaction once the MTP is greater than `T`. See BIP-0113.
+    ///
+    /// [BIP-0113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
+    ///
+    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid time value.
+    ///
+    /// # Errors
+    ///
+    /// If `n` is not in the allowable range of MTPs in a locktime: `[500_000_000, 2^32 - 1]`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::absolute;
+    /// assert!(absolute::LockTime::from_mtp(1653195600).is_ok());
+    /// assert!(absolute::LockTime::from_mtp(741521).is_err());
+    /// ```
+    #[inline]
+    pub fn from_mtp(n: u32) -> Result<Self, ConversionError> {
+        let time = MedianTimePast::from_u32(n)?;
+        Ok(Self::Seconds(time))
+    }
+
+    /// Returns true if both lock times use the same unit i.e., both height based or both time based.
+    #[inline]
+    pub const fn is_same_unit(self, other: Self) -> bool {
+        matches!(
+            (self, other),
+            (Self::Blocks(_), Self::Blocks(_)) | (Self::Seconds(_), Self::Seconds(_))
+        )
+    }
+
+    /// Returns true if this lock time value is a block height.
+    #[inline]
+    pub const fn is_block_height(self) -> bool { matches!(self, Self::Blocks(_)) }
+
+    /// Returns true if this lock time value is a block time (UNIX timestamp).
+    #[inline]
+    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
+
+    /// Returns true if this timelock constraint is satisfied by the respective `height`/`time`.
+    ///
+    /// If `self` is a blockheight based lock then it is checked against `height` and if `self` is a
+    /// blocktime based lock it is checked against `time`.
+    ///
+    /// A 'timelock constraint' refers to the `n` from `n OP_CHECKLOCKTIMEVERIFY`, this constraint
+    /// is satisfied if a transaction with `nLockTime` set to `height`/`time` is valid.
+    ///
+    /// If `height` and `mtp` represent the current chain tip then a transaction with this
+    /// locktime can be broadcast for inclusion in the next block.
+    ///
+    /// If you do not have, or do not wish to calculate, both parameters consider using:
+    ///
+    /// * [`is_satisfied_by_height()`](absolute::LockTime::is_satisfied_by_height)
+    /// * [`is_satisfied_by_time()`](absolute::LockTime::is_satisfied_by_time)
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # use bitcoin_units::absolute;
+    /// // Can be implemented if block chain data is available.
+    /// fn get_height() -> absolute::Height { todo!("return the current block height") }
+    /// fn get_time() -> absolute::MedianTimePast { todo!("return the current block MTP") }
+    ///
+    /// let n = absolute::LockTime::from_consensus(741521); // `n OP_CHECKLOCKTIMEVERIFY`.
+    /// if n.is_satisfied_by(get_height(), get_time()) {
+    ///     // Can create and mine a transaction that satisfies the OP_CLTV timelock constraint.
+    /// }
+    /// ````
+    #[inline]
+    pub fn is_satisfied_by(self, height: Height, mtp: MedianTimePast) -> bool {
+        match self {
+            Self::Blocks(blocks) => blocks.is_satisfied_by(height),
+            Self::Seconds(time) => time.is_satisfied_by(mtp),
+        }
+    }
+
+    /// Returns true if a transaction with this locktime can be spent in the next block.
+    ///
+    /// If `height` is the current block height of the chain then a transaction with this locktime
+    /// can be broadcast for inclusion in the next block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-height.
+    #[inline]
+    pub fn is_satisfied_by_height(self, height: Height) -> Result<bool, IncompatibleHeightError> {
+        match self {
+            Self::Blocks(blocks) => Ok(blocks.is_satisfied_by(height)),
+            Self::Seconds(time) =>
+                Err(IncompatibleHeightError { lock: time, incompatible: height }),
+        }
+    }
+
+    /// Returns true if a transaction with this locktime can be included in the next block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-time.
+    #[inline]
+    pub fn is_satisfied_by_time(self, mtp: MedianTimePast) -> Result<bool, IncompatibleTimeError> {
+        match self {
+            Self::Seconds(time) => Ok(time.is_satisfied_by(mtp)),
+            Self::Blocks(blocks) => Err(IncompatibleTimeError { lock: blocks, incompatible: mtp }),
+        }
+    }
+
+    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
+    /// [`absolute::LockTime`].
+    ///
+    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
+    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
+    /// mathematical sense) the smaller one being satisfied.
+    ///
+    /// This function serves multiple purposes:
+    ///
+    /// * When evaluating `OP_CHECKLOCKTIMEVERIFY` the argument must be less than or equal to the
+    ///   transactions nLockTime. If using this function to validate a script `self` is the argument
+    ///   to `CLTV` and `other` is the transaction nLockTime.
+    ///
+    /// * If you wish to check a lock time against various other locks e.g., filtering out locks
+    ///   which cannot be satisfied. Can also be used to remove the smaller value of two
+    ///   `OP_CHECKLOCKTIMEVERIFY` operations within one branch of the script.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::absolute;
+    /// let lock_time = absolute::LockTime::from_consensus(741521);
+    /// let check = absolute::LockTime::from_consensus(741521 + 1);
+    /// assert!(lock_time.is_implied_by(check));
+    /// ```
+    #[inline]
+    pub fn is_implied_by(self, other: Self) -> bool {
+        match (self, other) {
+            (Self::Blocks(this), Self::Blocks(other)) => this <= other,
+            (Self::Seconds(this), Self::Seconds(other)) => this <= other,
+            _ => false, // Not the same units.
+        }
+    }
+
+    /// Returns the inner `u32` value. This is the value used when creating this `LockTime`
+    /// i.e., `n OP_CHECKLOCKTIMEVERIFY` or `nLockTime`.
+    ///
+    /// # Warning
+    ///
+    /// Do not compare values return by this method. The whole point of the `LockTime` type is to
+    /// assist in doing correct comparisons. Either use `is_satisfied_by`, `is_satisfied_by_lock`,
+    /// or use the pattern below:
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::absolute::{self, LockTime as L};
+    /// # let n = absolute::LockTime::from_consensus(741521);  // n OP_CHECKLOCKTIMEVERIFY
+    /// # let lock_time = absolute::LockTime::from_consensus(741521 + 1);  // nLockTime
+    ///
+    /// let _is_satisfied = match (n, lock_time) {
+    ///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
+    ///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
+    ///     _ => panic!("invalid comparison"),
+    /// };
+    ///
+    /// // Or, if you have Rust 1.53 or greater
+    /// // let is_satisfied = n.partial_cmp(&lock_time).expect("invalid comparison").is_le();
+    /// ```
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 {
+        match self {
+            Self::Blocks(ref h) => h.to_u32(),
+            Self::Seconds(ref t) => t.to_u32(),
+        }
+    }
+}
+
+parse_int::impl_parse_str_from_int_infallible!(LockTime, u32, from_consensus);
+
+#[cfg(feature = "encoding")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`LockTime`] type.
+    pub struct LockTimeEncoder(encoding::ArrayEncoder<4>);
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Encodable for LockTime {
+    type Encoder<'e> = LockTimeEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        LockTimeEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_consensus_u32().to_le_bytes(),
+        ))
+    }
+}
+
+/// The decoder for the [`LockTime`] type.
+#[cfg(feature = "encoding")]
+pub struct LockTimeDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl LockTimeDecoder {
+    /// Constructs a new [`LockTime`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+#[cfg(feature = "encoding")]
+impl Default for LockTimeDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for LockTimeDecoder {
+    type Output = LockTime;
+    type Error = LockTimeDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes).map_err(LockTimeDecoderError)?)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end().map_err(LockTimeDecoderError)?);
+        Ok(LockTime::from_consensus(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for LockTime {
+    type Decoder = LockTimeDecoder;
+    fn decoder() -> Self::Decoder { LockTimeDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+impl From<Height> for LockTime {
+    #[inline]
+    fn from(h: Height) -> Self { Self::Blocks(h) }
+}
+
+impl From<MedianTimePast> for LockTime {
+    #[inline]
+    fn from(t: MedianTimePast) -> Self { Self::Seconds(t) }
+}
+
+impl fmt::Debug for LockTime {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Blocks(ref h) => write!(f, "{} blocks", h),
+            Self::Seconds(ref t) => write!(f, "{} seconds", t),
+        }
+    }
+}
+
+impl fmt::Display for LockTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if f.alternate() {
+            match *self {
+                Self::Blocks(ref h) => write!(f, "block-height {}", h),
+                Self::Seconds(ref t) => write!(f, "block-time {} (seconds since epoch)", t),
+            }
+        } else {
+            match *self {
+                Self::Blocks(ref h) => fmt::Display::fmt(h, f),
+                Self::Seconds(ref t) => fmt::Display::fmt(t, f),
+            }
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for LockTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_consensus_u32().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LockTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        u32::deserialize(deserializer).map(Self::from_consensus)
+    }
+}
+
+/// An absolute block height, guaranteed to always contain a valid height value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Height(u32);
+
+impl Height {
+    /// Absolute block height 0, the genesis block.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum absolute block height (0), the genesis block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum absolute block height.
+    pub const MAX: Self = Self(LOCK_TIME_THRESHOLD - 1);
+
+    /// Constructs a new [`Height`] from a hex string.
+    ///
+    /// The input string may or may not contain a typical hex prefix e.g., `0x`.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a block height.
+    pub fn from_hex(s: &str) -> Result<Self, ParseHeightError> { parse_hex(s, Self::from_u32) }
+
+    #[deprecated(since = "1.0.0-rc.0", note = "use `from_u32` instead")]
+    #[doc(hidden)]
+    pub const fn from_consensus(n: u32) -> Result<Self, ConversionError> { Self::from_u32(n) }
+
+    #[deprecated(since = "1.0.0-rc.0", note = "use `to_u32` instead")]
+    #[doc(hidden)]
+    pub const fn to_consensus_u32(self) -> u32 { self.to_u32() }
+
+    /// Constructs a new block height directly from a `u32` value.
+    ///
+    /// # Errors
+    ///
+    /// If `n` does not represent a block height within the valid range for a locktime:
+    /// `[0, 499_999_999]`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::locktime::absolute;
+    ///
+    /// let h: u32 = 741521;
+    /// let height = absolute::Height::from_u32(h)?;
+    /// assert_eq!(height.to_u32(), h);
+    /// # Ok::<_, absolute::error::ConversionError>(())
+    /// ```
+    #[inline]
+    pub const fn from_u32(n: u32) -> Result<Self, ConversionError> {
+        if is_block_height(n) {
+            Ok(Self(n))
+        } else {
+            Err(ConversionError::invalid_height(n))
+        }
+    }
+
+    /// Converts this [`Height`] to a raw `u32` value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::locktime::absolute;
+    ///
+    /// assert_eq!(absolute::Height::MAX.to_u32(), 499_999_999);
+    /// ```
+    #[inline]
+    pub const fn to_u32(self) -> u32 { self.0 }
+
+    /// Returns true if a transaction with this locktime can be included in the next block.
+    ///
+    /// `self` is value of the `LockTime` and if `height` is the current chain tip then
+    /// a transaction with this lock can be broadcast for inclusion in the next block.
+    #[inline]
+    pub fn is_satisfied_by(self, height: Self) -> bool {
+        // Use u64 so that there can be no overflow.
+        let next_block_height = u64::from(height.to_u32()) + 1;
+        u64::from(self.to_u32()) <= next_block_height
+    }
+}
+
+impl fmt::Display for Height {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+parse_int::impl_parse_str!(Height, ParseHeightError, parser(Height::from_u32));
+
+#[deprecated(since = "1.0.0-rc.0", note = "use `MedianTimePast` instead")]
+#[doc(hidden)]
+pub type Time = MedianTimePast;
+
+/// The median timestamp of 11 consecutive blocks, representing "the timestamp" of the
+/// final block for locktime-checking purposes.
+///
+/// Time-based locktimes are not measured against the timestamps in individual block
+/// headers, since these are not monotone and may be subject to miner manipulation.
+/// Instead, locktimes use the "median-time-past" (MTP) of the most recent 11 blocks,
+/// a quantity which is required by consensus to be monotone and which is difficult
+/// for any individual miner to manipulate.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MedianTimePast(u32);
+
+impl MedianTimePast {
+    /// The minimum MTP allowable in a locktime (Tue Nov 05 1985 00:53:20 GMT+0000).
+    pub const MIN: Self = Self(LOCK_TIME_THRESHOLD);
+
+    /// The maximum MTP allowable in a locktime (Sun Feb 07 2106 06:28:15 GMT+0000).
+    pub const MAX: Self = Self(u32::MAX);
+
+    /// Constructs an [`MedianTimePast`] by computing the median-time-past from the last
+    /// 11 block timestamps.
+    ///
+    /// Because block timestamps are not monotonic, this function internally sorts them;
+    /// it is therefore not important what order they appear in the array; use whatever
+    /// is most convenient.
+    ///
+    /// # Errors
+    ///
+    /// If the median block timestamp is not in the allowable range of MTPs in a
+    /// locktime: `[500_000_000, 2^32 - 1]`. Because there is a consensus rule that MTP
+    /// be monotonically increasing, and the MTP of the first 11 blocks exceeds `500_000_000`
+    /// for every real-life chain, this error typically cannot be hit in practice.
+    pub fn new(timestamps: [crate::BlockTime; 11]) -> Result<Self, ConversionError> {
+        crate::BlockMtp::new(timestamps).try_into()
+    }
+
+    /// Constructs a new [`MedianTimePast`] from a big-endian hex-encoded `u32`.
+    ///
+    /// The input string may or may not contain a typical hex prefix e.g., `0x`.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a block time.
+    pub fn from_hex(s: &str) -> Result<Self, ParseTimeError> { parse_hex(s, Self::from_u32) }
+
+    #[deprecated(since = "1.0.0-rc.0", note = "use `from_u32` instead")]
+    #[doc(hidden)]
+    pub const fn from_consensus(n: u32) -> Result<Self, ConversionError> { Self::from_u32(n) }
+
+    #[deprecated(since = "1.0.0-rc.0", note = "use `to_u32` instead")]
+    #[doc(hidden)]
+    pub const fn to_consensus_u32(self) -> u32 { self.to_u32() }
+
+    /// Constructs a new MTP directly from a `u32` value.
+    ///
+    /// This function, with [`MedianTimePast::to_u32`], is used to obtain a raw MTP value. It is
+    /// **not** used to convert to or from a block timestamp, which is not a MTP.
+    ///
+    /// # Errors
+    ///
+    /// If `n` is not in the allowable range of MTPs in a locktime: `[500_000_000, 2^32 - 1]`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::locktime::absolute;
+    ///
+    /// let t: u32 = 1653195600; // May 22nd, 5am UTC.
+    /// let time = absolute::MedianTimePast::from_u32(t)?;
+    /// assert_eq!(time.to_u32(), t);
+    /// # Ok::<_, absolute::error::ConversionError>(())
+    /// ```
+    #[inline]
+    pub const fn from_u32(n: u32) -> Result<Self, ConversionError> {
+        if is_block_time(n) {
+            Ok(Self(n))
+        } else {
+            Err(ConversionError::invalid_time(n))
+        }
+    }
+
+    /// Converts this [`MedianTimePast`] to a raw `u32` value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bitcoin_units::locktime::absolute;
+    ///
+    /// assert_eq!(absolute::MedianTimePast::MIN.to_u32(), 500_000_000);
+    /// ```
+    #[inline]
+    pub const fn to_u32(self) -> u32 { self.0 }
+
+    /// Returns true if a transaction with this locktime can be included in the next block.
+    ///
+    /// `self` is the value of the `LockTime` and if `time` is the median time past of the block at
+    /// the chain tip then a transaction with this lock can be broadcast for inclusion in the next
+    /// block.
+    #[inline]
+    pub fn is_satisfied_by(self, time: Self) -> bool {
+        // The locktime check in Core during block validation uses the MTP
+        // of the previous block - which is the expected to be `time` here.
+        self <= time
+    }
+}
+
+impl fmt::Display for MedianTimePast {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+parse_int::impl_parse_str!(MedianTimePast, ParseTimeError, parser(MedianTimePast::from_u32));
+
+fn parser<T, E, S, F>(f: F) -> impl FnOnce(S) -> Result<T, E>
+where
+    E: From<ParseError>,
+    S: AsRef<str> + Into<InputString>,
+    F: FnOnce(u32) -> Result<T, ConversionError>,
+{
+    move |s| {
+        let n = s.as_ref().parse::<i64>().map_err(ParseError::invalid_int(s))?;
+        let n = u32::try_from(n).map_err(|_| ParseError::Conversion(n))?;
+        f(n).map_err(ParseError::from).map_err(Into::into)
+    }
+}
+
+fn parse_hex<T, E, S, F>(s: S, f: F) -> Result<T, E>
+where
+    E: From<ParseError>,
+    S: AsRef<str> + Into<InputString>,
+    F: FnOnce(u32) -> Result<T, ConversionError>,
+{
+    let n = i64::from_str_radix(parse_int::hex_remove_optional_prefix(s.as_ref()), 16)
+        .map_err(ParseError::invalid_int(s))?;
+    let n = u32::try_from(n).map_err(|_| ParseError::Conversion(n))?;
+    f(n).map_err(ParseError::from).map_err(Into::into)
+}
+
+/// Returns true if `n` is a block height i.e., less than 500,000,000.
+pub const fn is_block_height(n: u32) -> bool { n < LOCK_TIME_THRESHOLD }
+
+/// Returns true if `n` is a UNIX timestamp i.e., greater than or equal to 500,000,000.
+pub const fn is_block_time(n: u32) -> bool { n >= LOCK_TIME_THRESHOLD }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for LockTime {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let l = u32::arbitrary(u)?;
+        Ok(Self::from_consensus(l))
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Height {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(Self::MIN),
+            1 => Ok(Self::MAX),
+            _ => {
+                let min = Self::MIN.to_u32();
+                let max = Self::MAX.to_u32();
+                let h = u.int_in_range(min..=max)?;
+                Ok(Self::from_u32(h).unwrap())
+            }
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for MedianTimePast {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(Self::MIN),
+            1 => Ok(Self::MAX),
+            _ => {
+                let min = Self::MIN.to_u32();
+                let max = Self::MAX.to_u32();
+                let t = u.int_in_range(min..=max)?;
+                Ok(Self::from_u32(t).unwrap())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::format;
+
+    use super::*;
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn display_and_alternate() {
+        let lock_by_height = LockTime::from_height(741_521).unwrap();
+        let lock_by_time = LockTime::from_mtp(1_653_195_600).unwrap(); // May 22nd 2022, 5am UTC.
+
+        assert_eq!(format!("{}", lock_by_height), "741521");
+        assert_eq!(format!("{:#}", lock_by_height), "block-height 741521");
+        assert!(!format!("{:?}", lock_by_height).is_empty());
+
+        assert_eq!(format!("{}", lock_by_time), "1653195600");
+        assert_eq!(format!("{:#}", lock_by_time), "block-time 1653195600 (seconds since epoch)");
+        assert!(!format!("{:?}", lock_by_time).is_empty());
+    }
+
+    #[test]
+    fn roundtrips() {
+        let lock_by_height = LockTime::from_consensus(741_521);
+        let lock_by_time = LockTime::from_consensus(1_653_195_600);
+
+        assert_eq!(lock_by_height.to_consensus_u32(), 741_521);
+        assert_eq!(lock_by_time.to_consensus_u32(), 1_653_195_600);
+    }
+
+    #[test]
+    fn lock_time_from_hex_lower() {
+        let lock_by_time = LockTime::from_hex("0x6289c350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
+    }
+
+    #[test]
+    fn lock_time_from_hex_upper() {
+        let lock_by_time = LockTime::from_hex("0X6289C350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
+    }
+
+    #[test]
+    fn lock_time_from_unprefixed_hex_lower() {
+        let lock_by_time = LockTime::from_unprefixed_hex("6289c350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
+    }
+
+    #[test]
+    fn lock_time_from_unprefixed_hex_upper() {
+        let lock_by_time = LockTime::from_unprefixed_hex("6289C350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
+    }
+
+    #[test]
+    fn invalid_hex() {
+        assert!(LockTime::from_hex("0xzb93").is_err());
+        assert!(LockTime::from_unprefixed_hex("zb93").is_err());
+    }
+
+    #[test]
+    fn invalid_locktime_type() {
+        assert!(LockTime::from_height(499_999_999).is_ok()); // Below the threshold.
+        assert!(LockTime::from_height(500_000_000).is_err()); // The threshold.
+        assert!(LockTime::from_height(500_000_001).is_err()); // Above the threshold.
+
+        assert!(LockTime::from_mtp(499_999_999).is_err()); // Below the threshold.
+        assert!(LockTime::from_mtp(500_000_000).is_ok()); // The threshold.
+        assert!(LockTime::from_mtp(500_000_001).is_ok()); // Above the threshold.
+    }
+
+    #[test]
+    fn parses_correctly_to_height_or_time() {
+        let lock_by_height = LockTime::from_consensus(750_000);
+
+        assert!(lock_by_height.is_block_height());
+        assert!(!lock_by_height.is_block_time());
+
+        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
+        let lock_by_time = LockTime::from_consensus(t);
+
+        assert!(!lock_by_time.is_block_height());
+        assert!(lock_by_time.is_block_time());
+
+        // Test is_same_unit() logic
+        assert!(lock_by_height.is_same_unit(LockTime::from_consensus(800_000)));
+        assert!(!lock_by_height.is_same_unit(lock_by_time));
+        assert!(lock_by_time.is_same_unit(LockTime::from_consensus(1_653_282_000)));
+        assert!(!lock_by_time.is_same_unit(lock_by_height));
+    }
+
+    #[test]
+    fn satisfied_by_height() {
+        let height_below = Height::from_u32(700_000).unwrap();
+        let height = Height::from_u32(750_000).unwrap();
+        let height_above = Height::from_u32(800_000).unwrap();
+
+        let lock_by_height = LockTime::from(height);
+
+        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
+        let time = MedianTimePast::from_u32(t).unwrap();
+
+        assert!(!lock_by_height.is_satisfied_by(height_below, time));
+        assert!(lock_by_height.is_satisfied_by(height, time));
+        assert!(lock_by_height.is_satisfied_by(height_above, time));
+    }
+
+    #[test]
+    fn satisfied_by_time() {
+        let time_before = MedianTimePast::from_u32(1_653_109_200).unwrap(); // "May 21th 2022, 5am UTC.
+        let time = MedianTimePast::from_u32(1_653_195_600).unwrap(); // "May 22nd 2022, 5am UTC.
+        let time_after = MedianTimePast::from_u32(1_653_282_000).unwrap(); // "May 23rd 2022, 5am UTC.
+
+        let lock_by_time = LockTime::from(time);
+
+        let height = Height::from_u32(800_000).unwrap();
+
+        assert!(!lock_by_time.is_satisfied_by(height, time_before));
+        assert!(lock_by_time.is_satisfied_by(height, time));
+        assert!(lock_by_time.is_satisfied_by(height, time_after));
+    }
+
+    #[test]
+    fn height_correctly_implies() {
+        let lock_by_height = LockTime::from_consensus(750_005);
+
+        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(750_004)));
+        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_005)));
+        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_006)));
+    }
+
+    #[test]
+    fn time_correctly_implies() {
+        let t: u32 = 1_700_000_005;
+        let lock_by_time = LockTime::from_consensus(t);
+
+        assert!(!lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_004)));
+        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_005)));
+        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_006)));
+    }
+
+    #[test]
+    fn incorrect_units_do_not_imply() {
+        let lock_by_height = LockTime::from_consensus(750_005);
+        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(1_700_000_004)));
+    }
+
+    #[test]
+    fn time_from_str_hex_happy_path() {
+        let actual = MedianTimePast::from_hex("0x6289C350").unwrap();
+        let expected = MedianTimePast::from_u32(0x6289_C350).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn time_from_str_hex_no_prefix_happy_path() {
+        let time = MedianTimePast::from_hex("6289C350").unwrap();
+        assert_eq!(time, MedianTimePast(0x6289_C350));
+    }
+
+    #[test]
+    fn time_from_str_hex_invalid_hex_should_err() {
+        let hex = "0xzb93";
+        let result = MedianTimePast::from_hex(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn height_from_str_hex_happy_path() {
+        let actual = Height::from_hex("0xBA70D").unwrap();
+        let expected = Height(0xBA70D);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn height_from_str_hex_no_prefix_happy_path() {
+        let height = Height::from_hex("BA70D").unwrap();
+        assert_eq!(height, Height(0xBA70D));
+    }
+
+    #[test]
+    fn height_from_str_hex_invalid_hex_should_err() {
+        let hex = "0xzb93";
+        let result = Height::from_hex(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn is_block_height_or_time() {
+        assert!(is_block_height(499_999_999));
+        assert!(!is_block_height(500_000_000));
+
+        assert!(!is_block_time(499_999_999));
+        assert!(is_block_time(500_000_000));
+    }
+
+    #[test]
+    fn valid_chain_computes_mtp() {
+        use crate::BlockTime;
+
+        let mut timestamps = [
+            BlockTime::from_u32(500_000_010),
+            BlockTime::from_u32(500_000_003),
+            BlockTime::from_u32(500_000_005),
+            BlockTime::from_u32(500_000_008),
+            BlockTime::from_u32(500_000_001),
+            BlockTime::from_u32(500_000_004),
+            BlockTime::from_u32(500_000_006),
+            BlockTime::from_u32(500_000_009),
+            BlockTime::from_u32(500_000_002),
+            BlockTime::from_u32(500_000_007),
+            BlockTime::from_u32(500_000_000),
+        ];
+
+        // Try various reorderings
+        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
+        timestamps.reverse();
+        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
+        timestamps.sort();
+        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
+        timestamps.reverse();
+        assert_eq!(MedianTimePast::new(timestamps).unwrap().to_u32(), 500_000_005);
+    }
+
+    #[test]
+    fn height_is_satisfied_by() {
+        let chain_tip = Height::from_u32(100).unwrap();
+
+        // lock is satisfied if transaction can go in the next block (height <= chain_tip + 1).
+        let locktime = Height::from_u32(100).unwrap();
+        assert!(locktime.is_satisfied_by(chain_tip));
+        let locktime = Height::from_u32(101).unwrap();
+        assert!(locktime.is_satisfied_by(chain_tip));
+
+        // It is not satisfied if the lock height is after the next block.
+        let locktime = Height::from_u32(102).unwrap();
+        assert!(!locktime.is_satisfied_by(chain_tip));
+    }
+
+    #[test]
+    fn median_time_past_is_satisfied_by() {
+        let mtp = MedianTimePast::from_u32(500_000_001).unwrap();
+
+        // lock is satisfied if transaction can go in the next block (locktime <= mtp).
+        let locktime = MedianTimePast::from_u32(500_000_000).unwrap();
+        assert!(locktime.is_satisfied_by(mtp));
+        let locktime = MedianTimePast::from_u32(500_000_001).unwrap();
+        assert!(locktime.is_satisfied_by(mtp));
+
+        // It is not satisfied if the lock time is after the median time past.
+        let locktime = MedianTimePast::from_u32(500_000_002).unwrap();
+        assert!(!locktime.is_satisfied_by(mtp));
+    }
+}
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
deleted file mode 100644
index 4aa330710a..0000000000
--- a/units/src/locktime/relative.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Provides [`NumberOfBlocks`] and [`NumberOf512Seconds`] types used by the
-//! `rust-bitcoin` `relative::LockTime` type.
-
-use core::fmt;
-
-#[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-#[deprecated(since = "TBD", note = "use `NumberOfBlocks` instead")]
-#[doc(hidden)]
-pub type Height = NumberOfBlocks;
-
-/// A relative lock time lock-by-blockheight value.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct NumberOfBlocks(u16);
-
-impl NumberOfBlocks {
-    /// Relative block height 0, can be included in any block.
-    pub const ZERO: Self = Self(0);
-
-    /// The minimum relative block height (0), can be included in any block.
-    pub const MIN: Self = Self::ZERO;
-
-    /// The maximum relative block height.
-    pub const MAX: Self = Self(u16::MAX);
-
-    /// Constructs a new [`NumberOfBlocks`] using a count of blocks.
-    #[inline]
-    pub const fn from_height(blocks: u16) -> Self { Self(blocks) }
-
-    /// Express the [`Height`] as a count of blocks.
-    #[inline]
-    #[must_use]
-    pub const fn to_height(self) -> u16 { self.0 }
-
-    /// Returns the inner `u16` value.
-    #[inline]
-    #[must_use]
-    #[deprecated(since = "TBD", note = "use `to_height` instead")]
-    #[doc(hidden)]
-    pub const fn value(self) -> u16 { self.0 }
-
-    /// Returns the `u32` value used to encode this locktime in an nSequence field or
-    /// argument to `OP_CHECKSEQUENCEVERIFY`.
-    #[deprecated(
-        since = "TBD",
-        note = "use `LockTime::from` followed by `to_consensus_u32` instead"
-    )]
-    pub const fn to_consensus_u32(self) -> u32 {
-        self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
-    }
-
-    /// Determines whether a relative‐height locktime has matured, taking into account
-    /// both the chain tip and the height at which the UTXO was confirmed.
-    ///
-    /// If you have two height intervals `x` and `y`, and want to know whether `x`
-    /// is satisfied by `y`, use `x >= y`.
-    ///
-    /// # Parameters
-    /// - `self` – the relative block‐height delay (`h`) required after confirmation.
-    /// - `chain_tip` – the height of the current chain tip
-    /// - `utxo_mined_at` – the height of the UTXO’s confirmation block
-    ///
-    /// # Returns
-    /// - `true` if a UTXO locked by `self` can be spent in a block after `chain_tip`.
-    /// - `false` if the UTXO is still locked at `chain_tip`.
-    pub fn is_satisfied_by(
-        self,
-        chain_tip: crate::BlockHeight,
-        utxo_mined_at: crate::BlockHeight,
-    ) -> bool {
-        chain_tip
-            .checked_sub(utxo_mined_at)
-            .and_then(|diff: crate::BlockHeightInterval| diff.try_into().ok())
-            .map_or(false, |diff: Self| diff >= self)
-    }
-}
-
-impl From<u16> for NumberOfBlocks {
-    #[inline]
-    fn from(value: u16) -> Self { NumberOfBlocks(value) }
-}
-
-crate::impl_parse_str_from_int_infallible!(NumberOfBlocks, u16, from);
-
-impl fmt::Display for NumberOfBlocks {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for NumberOfBlocks {
-    #[inline]
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        u16::serialize(&self.to_height(), s)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for NumberOfBlocks {
-    #[inline]
-    fn deserialize<D>(d: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Ok(Self::from_height(u16::deserialize(d)?))
-    }
-}
-
-#[deprecated(since = "TBD", note = "use `NumberOf512Seconds` instead")]
-#[doc(hidden)]
-pub type Time = NumberOf512Seconds;
-
-/// A relative lock time lock-by-blocktime value.
-///
-/// For BIP 68 relative lock-by-blocktime locks, time is measured in 512 second intervals.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct NumberOf512Seconds(u16);
-
-impl NumberOf512Seconds {
-    /// Relative block time 0, can be included in any block.
-    pub const ZERO: Self = NumberOf512Seconds(0);
-
-    /// The minimum relative block time (0), can be included in any block.
-    pub const MIN: Self = NumberOf512Seconds::ZERO;
-
-    /// The maximum relative block time (33,554,432 seconds or approx 388 days).
-    pub const MAX: Self = NumberOf512Seconds(u16::MAX);
-
-    /// Constructs a new [`NumberOf512Seconds`] using time intervals where each interval is equivalent to 512 seconds.
-    ///
-    /// Encoding finer granularity of time for relative lock-times is not supported in Bitcoin.
-    #[inline]
-    pub const fn from_512_second_intervals(intervals: u16) -> Self { NumberOf512Seconds(intervals) }
-
-    /// Express the [`NumberOf512Seconds`] as an integer number of 512-second intervals.
-    #[inline]
-    #[must_use]
-    pub const fn to_512_second_intervals(self) -> u16 { self.0 }
-
-    /// Constructs a new [`NumberOf512Seconds`] from seconds, converting the seconds into 512 second
-    /// interval with truncating division.
-    ///
-    /// # Errors
-    ///
-    /// Will return an error if the input cannot be encoded in 16 bits.
-    #[inline]
-    #[rustfmt::skip] // moves comments to unrelated code
-    pub const fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
-        let interval = seconds / 512;
-        if interval <= u16::MAX as u32 { // infallible cast, needed by const code
-            Ok(NumberOf512Seconds::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
-        } else {
-            Err(TimeOverflowError { seconds })
-        }
-    }
-
-    /// Constructs a new [`NumberOf512Seconds`] from seconds, converting the seconds into 512 second
-    /// intervals with ceiling division.
-    ///
-    /// # Errors
-    ///
-    /// Will return an error if the input cannot be encoded in 16 bits.
-    #[inline]
-    #[rustfmt::skip] // moves comments to unrelated code
-    pub const fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
-        if seconds <= u16::MAX as u32 * 512 {
-            let interval = (seconds + 511) / 512;
-            Ok(NumberOf512Seconds::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
-        } else {
-            Err(TimeOverflowError { seconds })
-        }
-    }
-
-    /// Represents the [`NumberOf512Seconds`] as an integer number of seconds.
-    #[inline]
-    pub const fn to_seconds(self) -> u32 {
-        self.0 as u32 * 512 // u16->u32 cast ok, const context
-    }
-
-    /// Returns the inner `u16` value.
-    #[inline]
-    #[must_use]
-    #[deprecated(since = "TBD", note = "use `to_512_second_intervals` instead")]
-    #[doc(hidden)]
-    pub const fn value(self) -> u16 { self.0 }
-
-    /// Returns the `u32` value used to encode this locktime in an nSequence field or
-    /// argument to `OP_CHECKSEQUENCEVERIFY`.
-    #[deprecated(
-        since = "TBD",
-        note = "use `LockTime::from` followed by `to_consensus_u32` instead"
-    )]
-    pub const fn to_consensus_u32(self) -> u32 {
-        (1u32 << 22) | self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
-    }
-
-    /// Determines whether a relative‑time lock has matured, taking into account both
-    /// the UTXO’s Median Time Past at confirmation and the required delay.
-    ///
-    /// If you have two MTP intervals `x` and `y`, and want to know whether `x`
-    /// is satisfied by `y`, use `x >= y`.
-    ///
-    /// # Parameters
-    /// - `self` – the relative time delay (`t`) in 512‑second intervals.
-    /// - `chain_tip` – the MTP of the current chain tip
-    /// - `utxo_mined_at` – the MTP of the UTXO’s confirmation block
-    ///
-    /// # Returns
-    /// - `true` if the relative‐time lock has expired by the tip’s MTP
-    /// - `false` if the lock has not yet expired by the tip’s MTP
-    pub fn is_satisfied_by(
-        self,
-        chain_tip: crate::BlockMtp,
-        utxo_mined_at: crate::BlockMtp,
-    ) -> bool {
-        chain_tip
-            .checked_sub(utxo_mined_at)
-            .and_then(|diff: crate::BlockMtpInterval| diff.to_relative_mtp_interval_floor().ok())
-            .map_or(false, |diff: Self| diff >= self)
-    }
-}
-
-crate::impl_parse_str_from_int_infallible!(NumberOf512Seconds, u16, from_512_second_intervals);
-
-impl fmt::Display for NumberOf512Seconds {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for NumberOf512Seconds {
-    #[inline]
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        u16::serialize(&self.to_512_second_intervals(), s)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for NumberOf512Seconds {
-    #[inline]
-    fn deserialize<D>(d: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Ok(Self::from_512_second_intervals(u16::deserialize(d)?))
-    }
-}
-
-/// Error returned when the input time in seconds was too large to be encoded to a 16 bit 512 second interval.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TimeOverflowError {
-    /// Time interval value in seconds that overflowed.
-    // Private because we maintain an invariant that the `seconds` value does actually overflow.
-    pub(crate) seconds: u32,
-}
-
-impl TimeOverflowError {
-    /// Constructs a new `TimeOverflowError` using `seconds`.
-    ///
-    /// # Panics
-    ///
-    /// If `seconds` would not actually overflow a `u16`.
-    pub fn new(seconds: u32) -> Self {
-        assert!(u16::try_from((seconds + 511) / 512).is_err());
-        Self { seconds }
-    }
-}
-
-impl fmt::Display for TimeOverflowError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{} seconds is too large to be encoded to a 16 bit 512 second interval",
-            self.seconds
-        )
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for TimeOverflowError {}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for NumberOfBlocks {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let choice = u.int_in_range(0..=2)?;
-
-        match choice {
-            0 => Ok(NumberOfBlocks::MIN),
-            1 => Ok(NumberOfBlocks::MAX),
-            _ => Ok(NumberOfBlocks::from_height(u16::arbitrary(u)?)),
-        }
-    }
-}
-
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for NumberOf512Seconds {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let choice = u.int_in_range(0..=2)?;
-
-        match choice {
-            0 => Ok(NumberOf512Seconds::MIN),
-            1 => Ok(NumberOf512Seconds::MAX),
-            _ => Ok(NumberOf512Seconds::from_512_second_intervals(u16::arbitrary(u)?)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[cfg(feature = "serde")]
-    use internals::serde_round_trip;
-
-    use super::*;
-    use crate::BlockTime;
-
-    const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;
-
-    #[test]
-    #[allow(deprecated_in_future)]
-    fn sanity_check() {
-        assert_eq!(NumberOfBlocks::MAX.to_consensus_u32(), u32::from(u16::MAX));
-        assert_eq!(NumberOf512Seconds::from_512_second_intervals(100).value(), 100u16);
-        assert_eq!(
-            NumberOf512Seconds::from_512_second_intervals(100).to_consensus_u32(),
-            4_194_404u32
-        ); // 0x400064
-    }
-
-    #[test]
-    fn from_seconds_ceil_success() {
-        let actual = NumberOf512Seconds::from_seconds_ceil(100).unwrap();
-        let expected = NumberOf512Seconds(1_u16);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn from_seconds_ceil_with_maximum_encodable_seconds_success() {
-        let actual = NumberOf512Seconds::from_seconds_ceil(MAXIMUM_ENCODABLE_SECONDS).unwrap();
-        let expected = NumberOf512Seconds(u16::MAX);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn from_seconds_ceil_causes_time_overflow_error() {
-        let result = NumberOf512Seconds::from_seconds_ceil(MAXIMUM_ENCODABLE_SECONDS + 1);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn from_seconds_floor_success() {
-        let actual = NumberOf512Seconds::from_seconds_floor(100).unwrap();
-        let expected = NumberOf512Seconds(0_u16);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn from_seconds_floor_with_exact_interval() {
-        let actual = NumberOf512Seconds::from_seconds_floor(512).unwrap();
-        let expected = NumberOf512Seconds(1_u16);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn from_seconds_floor_with_maximum_encodable_seconds_success() {
-        let actual =
-            NumberOf512Seconds::from_seconds_floor(MAXIMUM_ENCODABLE_SECONDS + 511).unwrap();
-        let expected = NumberOf512Seconds(u16::MAX);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn from_seconds_floor_causes_time_overflow_error() {
-        let result = NumberOf512Seconds::from_seconds_floor(MAXIMUM_ENCODABLE_SECONDS + 512);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_decode_height() {
-        serde_round_trip!(NumberOfBlocks::ZERO);
-        serde_round_trip!(NumberOfBlocks::MIN);
-        serde_round_trip!(NumberOfBlocks::MAX);
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_decode_time() {
-        serde_round_trip!(NumberOf512Seconds::ZERO);
-        serde_round_trip!(NumberOf512Seconds::MIN);
-        serde_round_trip!(NumberOf512Seconds::MAX);
-    }
-
-    fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
-        let mut timestamps = [BlockTime::from_u32(0); 11];
-        for (i, ts) in timestamps.iter_mut().enumerate() {
-            *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
-        }
-        timestamps
-    }
-
-    #[test]
-    fn test_time_chain_state() {
-        use crate::BlockMtp;
-
-        let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
-        let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
-
-        let timestamps2: [BlockTime; 11] = generate_timestamps(1_599_995_119, 200);
-        let utxo_timestamps2: [BlockTime; 11] = generate_timestamps(1_599_990_000, 200);
-
-        let timestamps3: [BlockTime; 11] = generate_timestamps(1_600_050_000, 200);
-        let utxo_timestamps3: [BlockTime; 11] = generate_timestamps(1_599_990_000, 200);
-
-        // Test case 1: Satisfaction (current_mtp >= utxo_mtp + required_seconds)
-        // 10 intervals × 512 seconds = 5120 seconds
-        let time_lock = NumberOf512Seconds::from_512_second_intervals(10);
-        let chain_state1 = BlockMtp::new(timestamps);
-        let utxo_state1 = BlockMtp::new(utxo_timestamps);
-        assert!(time_lock.is_satisfied_by(chain_state1, utxo_state1));
-
-        // Test case 2: Not satisfied (current_mtp < utxo_mtp + required_seconds)
-        let chain_state2 = BlockMtp::new(timestamps2);
-        let utxo_state2 = BlockMtp::new(utxo_timestamps2);
-        assert!(!time_lock.is_satisfied_by(chain_state2, utxo_state2));
-
-        // Test case 3: Test with a larger value (100 intervals = 51200 seconds)
-        let larger_lock = NumberOf512Seconds::from_512_second_intervals(100);
-        let chain_state3 = BlockMtp::new(timestamps3);
-        let utxo_state3 = BlockMtp::new(utxo_timestamps3);
-        assert!(larger_lock.is_satisfied_by(chain_state3, utxo_state3));
-
-        // Test case 4: Overflow handling - tests that is_satisfied_by handles overflow gracefully
-        let max_time_lock = NumberOf512Seconds::MAX;
-        let chain_state4 = BlockMtp::new(timestamps);
-        let utxo_state4 = BlockMtp::new(utxo_timestamps);
-        assert!(!max_time_lock.is_satisfied_by(chain_state4, utxo_state4));
-    }
-
-    #[test]
-    fn test_height_chain_state() {
-        use crate::BlockHeight;
-
-        let height_lock = NumberOfBlocks(10);
-
-        // Test case 1: Satisfaction (current_height >= utxo_height + required)
-        let chain_state1 = BlockHeight::from_u32(100);
-        let utxo_state1 = BlockHeight::from_u32(80);
-        assert!(height_lock.is_satisfied_by(chain_state1, utxo_state1));
-
-        // Test case 2: Not satisfied (current_height < utxo_height + required)
-        let chain_state2 = BlockHeight::from_u32(89);
-        let utxo_state2 = BlockHeight::from_u32(80);
-        assert!(!height_lock.is_satisfied_by(chain_state2, utxo_state2));
-
-        // Test case 3: Overflow handling - tests that is_satisfied_by handles overflow gracefully
-        let max_height_lock = NumberOfBlocks::MAX;
-        let chain_state3 = BlockHeight::from_u32(1000);
-        let utxo_state3 = BlockHeight::from_u32(80);
-        assert!(!max_height_lock.is_satisfied_by(chain_state3, utxo_state3));
-    }
-}
diff --git a/units/src/locktime/relative/error.rs b/units/src/locktime/relative/error.rs
new file mode 100644
index 0000000000..2113fb9cad
--- /dev/null
+++ b/units/src/locktime/relative/error.rs
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Error types for the relative locktime module.
+
+use core::fmt;
+
+use internals::write_err;
+
+use super::{NumberOf512Seconds, NumberOfBlocks};
+
+/// Error returned when a sequence number is parsed as a lock time, but its
+/// "disable" flag is set.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct DisabledLockTimeError(pub(super) u32);
+
+impl DisabledLockTimeError {
+    /// Accessor for the `u32` whose "disable" flag was set, preventing
+    /// it from being parsed as a relative locktime.
+    #[inline]
+    pub fn disabled_locktime_value(&self) -> u32 { self.0 }
+}
+
+impl fmt::Display for DisabledLockTimeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "lock time 0x{:08x} has disable flag set", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DisabledLockTimeError {}
+
+/// Error returned when attempting to satisfy lock fails.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum IsSatisfiedByError {
+    /// Error when attempting to satisfy lock by height.
+    Blocks(InvalidHeightError),
+    /// Error when attempting to satisfy lock by time.
+    Time(InvalidTimeError),
+}
+
+impl fmt::Display for IsSatisfiedByError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Blocks(ref e) => write_err!(f, "blocks"; e),
+            Self::Time(ref e) => write_err!(f, "time"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IsSatisfiedByError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Blocks(ref e) => Some(e),
+            Self::Time(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error returned when `is_satisfied_by_height` fails.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IsSatisfiedByHeightError {
+    /// Satisfaction of the lock height value failed.
+    Satisfaction(InvalidHeightError),
+    /// Tried to satisfy a lock-by-height locktime using seconds.
+    // TODO: Hide inner value in a new struct error type.
+    Incompatible(NumberOf512Seconds),
+}
+
+impl fmt::Display for IsSatisfiedByHeightError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Satisfaction(ref e) => write_err!(f, "satisfaction"; e),
+            Self::Incompatible(time) =>
+                write!(f, "tried to satisfy a lock-by-height locktime using seconds {}", time),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IsSatisfiedByHeightError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Satisfaction(ref e) => Some(e),
+            Self::Incompatible(_) => None,
+        }
+    }
+}
+
+/// Error returned when `is_satisfied_by_time` fails.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum IsSatisfiedByTimeError {
+    /// Satisfaction of the lock time value failed.
+    Satisfaction(InvalidTimeError),
+    /// Tried to satisfy a lock-by-time locktime using number of blocks.
+    // TODO: Hide inner value in a new struct error type.
+    Incompatible(NumberOfBlocks),
+}
+
+impl fmt::Display for IsSatisfiedByTimeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Satisfaction(ref e) => write_err!(f, "satisfaction"; e),
+            Self::Incompatible(blocks) =>
+                write!(f, "tried to satisfy a lock-by-time locktime using blocks {}", blocks),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IsSatisfiedByTimeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Satisfaction(ref e) => Some(e),
+            Self::Incompatible(_) => None,
+        }
+    }
+}
+
+/// Error returned when the input time in seconds was too large to be encoded to a 16 bit 512 second interval.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TimeOverflowError {
+    /// Time interval value in seconds that overflowed.
+    // Private because we maintain an invariant that the `seconds` value does actually overflow.
+    pub(crate) seconds: u32,
+}
+
+impl fmt::Display for TimeOverflowError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} seconds is too large to be encoded to a 16 bit 512 second interval",
+            self.seconds
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TimeOverflowError {}
+
+/// Error returned when `NumberOfBlocks::is_satisfied_by` is incorrectly called.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InvalidHeightError {
+    /// The `chain_tip` argument.
+    pub(crate) chain_tip: crate::BlockHeight,
+    /// The `utxo_mined_at` argument.
+    pub(crate) utxo_mined_at: crate::BlockHeight,
+}
+
+impl fmt::Display for InvalidHeightError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "is_satisfied_by arguments invalid (probably the wrong way around) chain_tip: {} utxo_mined_at: {}", self.chain_tip, self.utxo_mined_at
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidHeightError {}
+
+/// Error returned when `NumberOf512Seconds::is_satisfied_by` is incorrectly called.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InvalidTimeError {
+    /// The `chain_tip` argument.
+    pub(crate) chain_tip: crate::BlockMtp,
+    /// The `utxo_mined_at` argument.
+    pub(crate) utxo_mined_at: crate::BlockMtp,
+}
+
+impl fmt::Display for InvalidTimeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "is_satisfied_by arguments invalid (probably the wrong way around) chain_tip: {} utxo_mined_at: {}", self.chain_tip, self.utxo_mined_at
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidTimeError {}
diff --git a/units/src/locktime/relative/mod.rs b/units/src/locktime/relative/mod.rs
new file mode 100644
index 0000000000..c5d68d4bd3
--- /dev/null
+++ b/units/src/locktime/relative/mod.rs
@@ -0,0 +1,988 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides type [`LockTime`] that implements the logic around `nSequence`/`OP_CHECKSEQUENCEVERIFY`.
+//!
+//! There are two types of lock time: lock-by-height and lock-by-time, distinguished by whether bit
+//! 22 of the `u32` consensus value is set. To support these we provide the [`NumberOfBlocks`] and
+//! [`NumberOf512Seconds`] types.
+
+pub mod error;
+
+use core::{convert, fmt};
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+use internals::const_casts;
+
+#[cfg(doc)]
+use crate::relative;
+use crate::{parse_int, BlockHeight, BlockMtp, Sequence};
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(no_inline)]
+pub use self::error::{
+    DisabledLockTimeError, InvalidHeightError, InvalidTimeError, IsSatisfiedByError,
+    IsSatisfiedByHeightError, IsSatisfiedByTimeError, TimeOverflowError,
+};
+
+/// A relative lock time value, representing either a block height or time (512 second intervals).
+///
+/// Used for sequence numbers (`nSequence` in Bitcoin Core and `TxIn::sequence`
+/// in `rust-bitcoin`) and also for the argument to opcode `OP_CHECKSEQUENCEVERIFY`.
+///
+/// # Note on ordering
+///
+/// Locktimes may be height- or time-based, and these metrics are incommensurate; there is no total
+/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
+/// [`LockTime::is_satisfied_by`] API.
+///
+/// # Relevant BIPs
+///
+/// * [BIP-0068 Relative lock-time using consensus-enforced sequence numbers](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki)
+/// * [BIP-0112 CHECKSEQUENCEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LockTime {
+    /// A block height lock time value.
+    Blocks(NumberOfBlocks),
+    /// A 512 second time interval value.
+    Time(NumberOf512Seconds),
+}
+
+impl LockTime {
+    /// A relative locktime of 0 is always valid, and is assumed valid for inputs that
+    /// are not yet confirmed.
+    pub const ZERO: Self = Self::Blocks(NumberOfBlocks::ZERO);
+
+    /// The number of bytes that the locktime contributes to the size of a transaction.
+    pub const SIZE: usize = 4; // Serialized length of a u32.
+
+    /// Constructs a new `LockTime` from an `nSequence` value or the argument to `OP_CHECKSEQUENCEVERIFY`.
+    ///
+    /// This method will **not** round-trip with [`Self::to_consensus_u32`], because relative
+    /// locktimes only use some bits of the underlying `u32` value and discard the rest. If
+    /// you want to preserve the full value, you should use the [`Sequence`] type instead.
+    ///
+    /// # Errors
+    ///
+    /// If `n`, interpreted as a [`Sequence`] number does not encode a relative lock time.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::relative;
+    ///
+    /// // Values with bit 22 set to 0 will be interpreted as height-based lock times.
+    /// let height: u32 = 144; // 144 blocks, approx 24h.
+    /// let lock_time = relative::LockTime::from_consensus(height)?;
+    /// assert!(lock_time.is_block_height());
+    /// assert_eq!(lock_time.to_consensus_u32(), height);
+    ///
+    /// // Values with bit 22 set to 1 will be interpreted as time-based lock times.
+    /// let time: u32 = 168 | (1 << 22) ; // Bit 22 is 1 with time approx 24h.
+    /// let lock_time = relative::LockTime::from_consensus(time)?;
+    /// assert!(lock_time.is_block_time());
+    /// assert_eq!(lock_time.to_consensus_u32(), time);
+    ///
+    /// # Ok::<_, relative::error::DisabledLockTimeError>(())
+    /// ```
+    #[inline]
+    pub fn from_consensus(n: u32) -> Result<Self, DisabledLockTimeError> {
+        let sequence = crate::Sequence::from_consensus(n);
+        sequence.to_relative_lock_time().ok_or(DisabledLockTimeError(n))
+    }
+
+    /// Returns the `u32` value used to encode this locktime in an `nSequence` field or
+    /// argument to `OP_CHECKSEQUENCEVERIFY`.
+    ///
+    /// # Warning
+    ///
+    /// Locktimes are not ordered by the natural ordering on `u32`. If you want to
+    /// compare locktimes, use [`Self::is_implied_by`] or similar methods.
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 {
+        match self {
+            Self::Blocks(ref h) => u32::from(h.to_height()),
+            Self::Time(ref t) => Sequence::LOCK_TYPE_MASK | u32::from(t.to_512_second_intervals()),
+        }
+    }
+
+    /// Constructs a new `LockTime` from the sequence number of a Bitcoin input.
+    ///
+    /// This method will **not** round-trip with [`Self::to_sequence`]. See the
+    /// docs for [`Self::from_consensus`] for more information.
+    ///
+    /// # Errors
+    ///
+    /// If `n` does not encode a relative lock time.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::{Sequence, relative};
+    ///
+    /// // Interpret a sequence number from a Bitcoin transaction input as a relative lock time
+    /// let sequence_number = Sequence::from_consensus(144); // 144 blocks, approx 24h.
+    /// let lock_time = relative::LockTime::from_sequence(sequence_number)?;
+    /// assert!(lock_time.is_block_height());
+    ///
+    /// # Ok::<_, relative::error::DisabledLockTimeError>(())
+    /// ```
+    #[inline]
+    pub fn from_sequence(n: Sequence) -> Result<Self, DisabledLockTimeError> {
+        Self::from_consensus(n.to_consensus_u32())
+    }
+
+    /// Encodes the locktime as a sequence number.
+    #[inline]
+    pub fn to_sequence(self) -> Sequence { Sequence::from_consensus(self.to_consensus_u32()) }
+
+    /// Constructs a new `LockTime` from `n`, expecting `n` to be a 16-bit count of blocks.
+    #[inline]
+    pub const fn from_height(n: u16) -> Self { Self::Blocks(NumberOfBlocks::from_height(n)) }
+
+    /// Constructs a new `LockTime` from `n`, expecting `n` to be a count of 512-second intervals.
+    ///
+    /// This function is a little awkward to use, and users may wish to instead use
+    /// [`Self::from_seconds_floor`] or [`Self::from_seconds_ceil`].
+    #[inline]
+    pub const fn from_512_second_intervals(intervals: u16) -> Self {
+        Self::Time(NumberOf512Seconds::from_512_second_intervals(intervals))
+    }
+
+    /// Constructs a new [`LockTime`] from seconds, converting the seconds into 512 second interval
+    /// with truncating division.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    pub const fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
+        match NumberOf512Seconds::from_seconds_floor(seconds) {
+            Ok(time) => Ok(Self::Time(time)),
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Constructs a new [`LockTime`] from seconds, converting the seconds into 512 second interval
+    /// with ceiling division.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    pub const fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
+        match NumberOf512Seconds::from_seconds_ceil(seconds) {
+            Ok(time) => Ok(Self::Time(time)),
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Returns true if both lock times use the same unit i.e., both height based or both time based.
+    #[inline]
+    pub const fn is_same_unit(self, other: Self) -> bool {
+        matches!((self, other), (Self::Blocks(_), Self::Blocks(_)) | (Self::Time(_), Self::Time(_)))
+    }
+
+    /// Returns true if this lock time value is in units of block height.
+    #[inline]
+    pub const fn is_block_height(self) -> bool { matches!(self, Self::Blocks(_)) }
+
+    /// Returns true if this lock time value is in units of time.
+    #[inline]
+    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
+
+    /// Returns true if this [`relative::LockTime`] is satisfied by the given chain state.
+    ///
+    /// If this function returns true then an output with this locktime can be spent in the next
+    /// block.
+    ///
+    /// # Errors
+    ///
+    /// If `chain_tip` as not _after_ `utxo_mined_at` i.e., if you get the args mixed up.
+    pub fn is_satisfied_by(
+        self,
+        chain_tip_height: BlockHeight,
+        chain_tip_mtp: BlockMtp,
+        utxo_mined_at_height: BlockHeight,
+        utxo_mined_at_mtp: BlockMtp,
+    ) -> Result<bool, IsSatisfiedByError> {
+        match self {
+            Self::Blocks(blocks) => blocks
+                .is_satisfied_by(chain_tip_height, utxo_mined_at_height)
+                .map_err(IsSatisfiedByError::Blocks),
+            Self::Time(time) => time
+                .is_satisfied_by(chain_tip_mtp, utxo_mined_at_mtp)
+                .map_err(IsSatisfiedByError::Time),
+        }
+    }
+
+    /// Returns true if an output with this locktime can be spent in the next block.
+    ///
+    /// If this function returns true then an output with this locktime can be spent in the next
+    /// block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-height.
+    #[inline]
+    pub fn is_satisfied_by_height(
+        self,
+        chain_tip: BlockHeight,
+        utxo_mined_at: BlockHeight,
+    ) -> Result<bool, IsSatisfiedByHeightError> {
+        match self {
+            Self::Blocks(blocks) => blocks
+                .is_satisfied_by(chain_tip, utxo_mined_at)
+                .map_err(IsSatisfiedByHeightError::Satisfaction),
+            Self::Time(time) => Err(IsSatisfiedByHeightError::Incompatible(time)),
+        }
+    }
+
+    /// Returns true if an output with this locktime can be spent in the next block.
+    ///
+    /// If this function returns true then an output with this locktime can be spent in the next
+    /// block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-time.
+    #[inline]
+    pub fn is_satisfied_by_time(
+        self,
+        chain_tip: BlockMtp,
+        utxo_mined_at: BlockMtp,
+    ) -> Result<bool, IsSatisfiedByTimeError> {
+        match self {
+            Self::Time(time) => time
+                .is_satisfied_by(chain_tip, utxo_mined_at)
+                .map_err(IsSatisfiedByTimeError::Satisfaction),
+            Self::Blocks(blocks) => Err(IsSatisfiedByTimeError::Incompatible(blocks)),
+        }
+    }
+
+    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
+    /// [`relative::LockTime`].
+    ///
+    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
+    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
+    /// mathematical sense) the smaller one being satisfied.
+    ///
+    /// This function is useful when checking sequence values against a lock, first one checks the
+    /// sequence represents a relative lock time by converting to `LockTime` then use this function
+    /// to see if satisfaction of the newly created lock time would imply satisfaction of `self`.
+    ///
+    /// Can also be used to remove the smaller value of two `OP_CHECKSEQUENCEVERIFY` operations
+    /// within one branch of the script.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_units::Sequence;
+    ///
+    /// # let required_height = 100;       // 100 blocks.
+    /// # let lock = Sequence::from_height(required_height).to_relative_lock_time().expect("valid height");
+    /// # let test_sequence = Sequence::from_height(required_height + 10);
+    ///
+    /// let satisfied = match test_sequence.to_relative_lock_time() {
+    ///     None => false, // Handle non-lock-time case.
+    ///     Some(test_lock) => lock.is_implied_by(test_lock),
+    /// };
+    /// assert!(satisfied);
+    /// ```
+    #[inline]
+    pub fn is_implied_by(self, other: Self) -> bool {
+        match (self, other) {
+            (Self::Blocks(this), Self::Blocks(other)) => this <= other,
+            (Self::Time(this), Self::Time(other)) => this <= other,
+            _ => false, // Not the same units.
+        }
+    }
+
+    /// Returns true if satisfaction of the sequence number implies satisfaction of this lock time.
+    ///
+    /// When deciding whether an instance of `<n> CHECKSEQUENCEVERIFY` will pass, this
+    /// method can be used by parsing `n` as a [`LockTime`] and calling this method
+    /// with the sequence number of the input which spends the script.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{Sequence, relative};
+    ///
+    /// let sequence = Sequence::from_consensus(1 << 22 | 168); // Bit 22 is 1 with time approx 24h.
+    /// let lock_time = relative::LockTime::from_sequence(sequence)?;
+    /// let input_sequence = Sequence::from_consensus(1 << 22 | 336); // Approx 48h.
+    /// assert!(lock_time.is_block_time());
+    ///
+    /// assert!(lock_time.is_implied_by_sequence(input_sequence));
+    ///
+    /// # Ok::<_, relative::error::DisabledLockTimeError>(())
+    /// ```
+    #[inline]
+    pub fn is_implied_by_sequence(self, other: Sequence) -> bool {
+        if let Ok(other) = Self::from_sequence(other) {
+            self.is_implied_by(other)
+        } else {
+            false
+        }
+    }
+}
+
+impl From<NumberOfBlocks> for LockTime {
+    #[inline]
+    fn from(h: NumberOfBlocks) -> Self { Self::Blocks(h) }
+}
+
+impl From<NumberOf512Seconds> for LockTime {
+    #[inline]
+    fn from(t: NumberOf512Seconds) -> Self { Self::Time(t) }
+}
+
+impl fmt::Display for LockTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if f.alternate() {
+            match *self {
+                Self::Blocks(ref h) => write!(f, "block-height {}", h),
+                Self::Time(ref t) => write!(f, "block-time {} (512 second intervals)", t),
+            }
+        } else {
+            match *self {
+                Self::Blocks(ref h) => fmt::Display::fmt(h, f),
+                Self::Time(ref t) => fmt::Display::fmt(t, f),
+            }
+        }
+    }
+}
+
+impl convert::TryFrom<Sequence> for LockTime {
+    type Error = DisabledLockTimeError;
+    #[inline]
+    fn try_from(seq: Sequence) -> Result<Self, DisabledLockTimeError> { Self::from_sequence(seq) }
+}
+
+impl From<LockTime> for Sequence {
+    #[inline]
+    fn from(lt: LockTime) -> Self { lt.to_sequence() }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for LockTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_consensus_u32().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LockTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        u32::deserialize(deserializer)
+            .and_then(|n| Self::from_consensus(n).map_err(serde::de::Error::custom))
+    }
+}
+
+#[deprecated(since = "1.0.0-rc.0", note = "use `NumberOfBlocks` instead")]
+#[doc(hidden)]
+pub type Height = NumberOfBlocks;
+
+/// A relative lock time lock-by-height value.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct NumberOfBlocks(u16);
+
+impl NumberOfBlocks {
+    /// Relative block height 0, can be included in any block.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum relative block height (0), can be included in any block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum relative block height.
+    pub const MAX: Self = Self(u16::MAX);
+
+    /// Constructs a new [`NumberOfBlocks`] using a count of blocks.
+    #[inline]
+    pub const fn from_height(blocks: u16) -> Self { Self(blocks) }
+
+    /// Express the [`NumberOfBlocks`] as a count of blocks.
+    #[inline]
+    #[must_use]
+    pub const fn to_height(self) -> u16 { self.0 }
+
+    /// Returns the inner `u16` value.
+    #[inline]
+    #[must_use]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `to_height` instead")]
+    #[doc(hidden)]
+    pub const fn value(self) -> u16 { self.0 }
+
+    /// Returns the `u32` value used to encode this locktime in an nSequence field or
+    /// argument to `OP_CHECKSEQUENCEVERIFY`.
+    #[deprecated(
+        since = "1.0.0-rc.0",
+        note = "use `LockTime::from` followed by `to_consensus_u32` instead"
+    )]
+    pub const fn to_consensus_u32(self) -> u32 {
+        self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
+    }
+
+    /// Returns true if an output locked by height can be spent in the next block.
+    ///
+    /// # Errors
+    ///
+    /// If `chain_tip` as not _after_ `utxo_mined_at` i.e., if you get the args mixed up.
+    pub fn is_satisfied_by(
+        self,
+        chain_tip: crate::BlockHeight,
+        utxo_mined_at: crate::BlockHeight,
+    ) -> Result<bool, InvalidHeightError> {
+        match chain_tip.checked_sub(utxo_mined_at) {
+            Some(diff) => {
+                if diff.to_u32() == u32::MAX {
+                    // Weird but ok none the less - protects against overflow below.
+                    return Ok(true);
+                }
+                // +1 because the next block will have height 1 higher than `chain_tip`.
+                Ok(u32::from(self.to_height()) <= diff.to_u32() + 1)
+            }
+            None => Err(InvalidHeightError { chain_tip, utxo_mined_at }),
+        }
+    }
+}
+
+impl From<u16> for NumberOfBlocks {
+    #[inline]
+    fn from(value: u16) -> Self { Self(value) }
+}
+
+parse_int::impl_parse_str_from_int_infallible!(NumberOfBlocks, u16, from);
+
+impl fmt::Display for NumberOfBlocks {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+#[deprecated(since = "1.0.0-rc.0", note = "use `NumberOf512Seconds` instead")]
+#[doc(hidden)]
+pub type Time = NumberOf512Seconds;
+
+/// A relative lock time lock-by-time value.
+///
+/// For BIP-0068 relative lock-by-time locks, time is measured in 512 second intervals.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct NumberOf512Seconds(u16);
+
+impl NumberOf512Seconds {
+    /// Relative block time 0, can be included in any block.
+    pub const ZERO: Self = Self(0);
+
+    /// The minimum relative block time (0), can be included in any block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum relative block time (33,554,432 seconds or approx 388 days).
+    pub const MAX: Self = Self(u16::MAX);
+
+    /// Constructs a new [`NumberOf512Seconds`] using time intervals where each interval is
+    /// equivalent to 512 seconds.
+    ///
+    /// Encoding finer granularity of time for relative lock-times is not supported in Bitcoin.
+    #[inline]
+    pub const fn from_512_second_intervals(intervals: u16) -> Self { Self(intervals) }
+
+    /// Express the [`NumberOf512Seconds`] as an integer number of 512-second intervals.
+    #[inline]
+    #[must_use]
+    pub const fn to_512_second_intervals(self) -> u16 { self.0 }
+
+    /// Constructs a new [`NumberOf512Seconds`] from seconds, converting the seconds into a 512
+    /// second interval using truncating division.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    #[rustfmt::skip] // moves comments to unrelated code
+    pub const fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
+        let interval = seconds / 512;
+        if interval <= u16::MAX as u32 { // infallible cast, needed by const code
+            Ok(Self::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
+        } else {
+            Err(TimeOverflowError { seconds })
+        }
+    }
+
+    /// Constructs a new [`NumberOf512Seconds`] from seconds, converting the seconds into a 512
+    /// second interval using ceiling division.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    #[rustfmt::skip] // moves comments to unrelated code
+    pub const fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
+        if seconds <= u16::MAX as u32 * 512 {
+            let interval = seconds.div_ceil(512);
+            Ok(Self::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
+        } else {
+            Err(TimeOverflowError { seconds })
+        }
+    }
+
+    /// Represents the [`NumberOf512Seconds`] as an integer number of seconds.
+    #[inline]
+    pub const fn to_seconds(self) -> u32 { const_casts::u16_to_u32(self.0) * 512 }
+
+    /// Returns the inner `u16` value.
+    #[inline]
+    #[must_use]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `to_512_second_intervals` instead")]
+    #[doc(hidden)]
+    pub const fn value(self) -> u16 { self.0 }
+
+    /// Returns the `u32` value used to encode this locktime in an nSequence field or
+    /// argument to `OP_CHECKSEQUENCEVERIFY`.
+    #[deprecated(
+        since = "1.0.0-rc.0",
+        note = "use `LockTime::from` followed by `to_consensus_u32` instead"
+    )]
+    pub const fn to_consensus_u32(self) -> u32 {
+        (1u32 << 22) | self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
+    }
+
+    /// Returns true if an output locked by time can be spent in the next block.
+    ///
+    /// # Errors
+    ///
+    /// If `chain_tip` as not _after_ `utxo_mined_at` i.e., if you get the args mixed up.
+    pub fn is_satisfied_by(
+        self,
+        chain_tip: crate::BlockMtp,
+        utxo_mined_at: crate::BlockMtp,
+    ) -> Result<bool, InvalidTimeError> {
+        match chain_tip.checked_sub(utxo_mined_at) {
+            Some(diff) => {
+                // The locktime check in Core during block validation uses the MTP of the previous
+                // block - which is `chain_tip` here.
+                Ok(self.to_seconds() <= diff.to_u32())
+            }
+            None => Err(InvalidTimeError { chain_tip, utxo_mined_at }),
+        }
+    }
+}
+
+parse_int::impl_parse_str_from_int_infallible!(NumberOf512Seconds, u16, from_512_second_intervals);
+
+impl fmt::Display for NumberOf512Seconds {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for NumberOfBlocks {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+
+        match choice {
+            0 => Ok(Self::MIN),
+            1 => Ok(Self::MAX),
+            _ => Ok(Self::from_height(u16::arbitrary(u)?)),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for NumberOf512Seconds {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+
+        match choice {
+            0 => Ok(Self::MIN),
+            1 => Ok(Self::MAX),
+            _ => Ok(Self::from_512_second_intervals(u16::arbitrary(u)?)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "alloc")]
+    use alloc::format;
+
+    use super::*;
+    use crate::{BlockHeight, BlockTime};
+
+    const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn display_and_alternate() {
+        let lock_by_height = LockTime::from_height(10);
+        let lock_by_time = LockTime::from_512_second_intervals(70);
+
+        assert_eq!(format!("{}", lock_by_height), "10");
+        assert_eq!(format!("{:#}", lock_by_height), "block-height 10");
+        assert!(!format!("{:?}", lock_by_height).is_empty());
+
+        assert_eq!(format!("{}", lock_by_time), "70");
+        assert_eq!(format!("{:#}", lock_by_time), "block-time 70 (512 second intervals)");
+        assert!(!format!("{:?}", lock_by_time).is_empty());
+    }
+
+    #[test]
+    fn from_seconds_ceil_and_floor() {
+        let time = 70 * 512 + 1;
+        let lock_by_time = LockTime::from_seconds_ceil(time).unwrap();
+        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(71));
+
+        let lock_by_time = LockTime::from_seconds_floor(time).unwrap();
+        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(70));
+
+        let mut max_time = 0xffff * 512;
+        assert_eq!(LockTime::from_seconds_ceil(max_time), LockTime::from_seconds_floor(max_time));
+        max_time += 512;
+        assert!(LockTime::from_seconds_ceil(max_time).is_err());
+        assert!(LockTime::from_seconds_floor(max_time).is_err());
+    }
+
+    #[test]
+    fn parses_correctly_to_height_or_time() {
+        let height1 = NumberOfBlocks::from(10);
+        let height2 = NumberOfBlocks::from(11);
+        let time1 = NumberOf512Seconds::from_512_second_intervals(70);
+        let time2 = NumberOf512Seconds::from_512_second_intervals(71);
+
+        let lock_by_height1 = LockTime::from(height1);
+        let lock_by_height2 = LockTime::from(height2);
+        let lock_by_time1 = LockTime::from(time1);
+        let lock_by_time2 = LockTime::from(time2);
+
+        assert!(lock_by_height1.is_block_height());
+        assert!(!lock_by_height1.is_block_time());
+
+        assert!(!lock_by_time1.is_block_height());
+        assert!(lock_by_time1.is_block_time());
+
+        // Test is_same_unit() logic
+        assert!(lock_by_height1.is_same_unit(lock_by_height2));
+        assert!(!lock_by_height1.is_same_unit(lock_by_time1));
+        assert!(lock_by_time1.is_same_unit(lock_by_time2));
+        assert!(!lock_by_time1.is_same_unit(lock_by_height1));
+    }
+
+    #[test]
+    fn height_correctly_implies() {
+        let height = NumberOfBlocks::from(10);
+        let lock_by_height = LockTime::from(height);
+
+        assert!(!lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(9))));
+        assert!(lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(10))));
+        assert!(lock_by_height.is_implied_by(LockTime::from(NumberOfBlocks::from(11))));
+    }
+
+    #[test]
+    fn time_correctly_implies() {
+        let time = NumberOf512Seconds::from_512_second_intervals(70);
+        let lock_by_time = LockTime::from(time);
+
+        assert!(!lock_by_time
+            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(69))));
+        assert!(lock_by_time
+            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(70))));
+        assert!(lock_by_time
+            .is_implied_by(LockTime::from(NumberOf512Seconds::from_512_second_intervals(71))));
+    }
+
+    #[test]
+    fn sequence_correctly_implies() {
+        let height = NumberOfBlocks::from(10);
+        let time = NumberOf512Seconds::from_512_second_intervals(70);
+
+        let lock_by_height = LockTime::from(height);
+        let lock_by_time = LockTime::from(time);
+
+        let seq_height = Sequence::from(lock_by_height);
+        let seq_time = Sequence::from(lock_by_time);
+
+        assert!(lock_by_height.is_implied_by_sequence(seq_height));
+        assert!(!lock_by_height.is_implied_by_sequence(seq_time));
+
+        assert!(lock_by_time.is_implied_by_sequence(seq_time));
+        assert!(!lock_by_time.is_implied_by_sequence(seq_height));
+
+        let disabled_sequence = Sequence::from_consensus(1 << 31);
+        assert!(!lock_by_height.is_implied_by_sequence(disabled_sequence));
+        assert!(!lock_by_time.is_implied_by_sequence(disabled_sequence));
+    }
+
+    #[test]
+    fn incorrect_units_do_not_imply() {
+        let time = NumberOf512Seconds::from_512_second_intervals(70);
+        let height = NumberOfBlocks::from(10);
+
+        let lock_by_time = LockTime::from(time);
+        assert!(!lock_by_time.is_implied_by(LockTime::from(height)));
+    }
+
+    #[test]
+    fn consensus_round_trip() {
+        assert!(LockTime::from_consensus(1 << 31).is_err());
+        assert!(LockTime::from_consensus(1 << 30).is_ok());
+        // Relative locktimes do not care about bits 17 through 21.
+        assert_eq!(LockTime::from_consensus(65536), LockTime::from_consensus(0));
+
+        for val in [0u32, 1, 1000, 65535] {
+            let seq = Sequence::from_consensus(val);
+            let lt = LockTime::from_consensus(val).unwrap();
+            assert_eq!(lt.to_consensus_u32(), val);
+            assert_eq!(lt.to_sequence(), seq);
+            assert_eq!(LockTime::from_sequence(seq).unwrap().to_sequence(), seq);
+
+            let seq = Sequence::from_consensus(val + (1 << 22));
+            let lt = LockTime::from_consensus(val + (1 << 22)).unwrap();
+            assert_eq!(lt.to_consensus_u32(), val + (1 << 22));
+            assert_eq!(lt.to_sequence(), seq);
+            assert_eq!(LockTime::from_sequence(seq).unwrap().to_sequence(), seq);
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn disabled_locktime_error() {
+        let disabled_sequence = Sequence::from_consensus(1 << 31);
+        let err = LockTime::try_from(disabled_sequence).unwrap_err();
+
+        assert_eq!(err.disabled_locktime_value(), 1 << 31);
+        assert!(!format!("{}", err).is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn incompatible_height_error() {
+        // This is an error test these values are not used in the error path.
+        let mined_at = BlockHeight::from_u32(700_000);
+        let chain_tip = BlockHeight::from_u32(800_000);
+
+        let lock_by_time = LockTime::from_512_second_intervals(70); // Arbitrary value.
+        let err = lock_by_time.is_satisfied_by_height(chain_tip, mined_at).unwrap_err();
+
+        let expected_time = NumberOf512Seconds::from_512_second_intervals(70);
+        assert_eq!(err, IsSatisfiedByHeightError::Incompatible(expected_time));
+        assert!(!format!("{}", err).is_empty());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn incompatible_time_error() {
+        // This is an error test these values are not used in the error path.
+        let mined_at = BlockMtp::from_u32(1_234_567_890);
+        let chain_tip = BlockMtp::from_u32(1_600_000_000);
+
+        let lock_by_height = LockTime::from_height(10); // Arbitrary value.
+        let err = lock_by_height.is_satisfied_by_time(chain_tip, mined_at).unwrap_err();
+
+        let expected_height = NumberOfBlocks::from(10);
+        assert_eq!(err, IsSatisfiedByTimeError::Incompatible(expected_height));
+        assert!(!format!("{}", err).is_empty());
+    }
+
+    #[test]
+    fn test_locktime_chain_state() {
+        fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
+            let mut timestamps = [BlockTime::from_u32(0); 11];
+            for (i, ts) in timestamps.iter_mut().enumerate() {
+                *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
+            }
+            timestamps
+        }
+
+        let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
+        let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
+
+        let chain_height = BlockHeight::from_u32(100);
+        let chain_mtp = BlockMtp::new(timestamps);
+        let utxo_height = BlockHeight::from_u32(80);
+        let utxo_mtp = BlockMtp::new(utxo_timestamps);
+
+        let lock1 = LockTime::Blocks(NumberOfBlocks::from(10));
+        assert!(lock1.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp).unwrap());
+
+        let lock2 = LockTime::Blocks(NumberOfBlocks::from(21));
+        assert!(lock2.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp).unwrap());
+
+        let lock3 = LockTime::Time(NumberOf512Seconds::from_512_second_intervals(10));
+        assert!(lock3.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp).unwrap());
+
+        let lock4 = LockTime::Time(NumberOf512Seconds::from_512_second_intervals(20000));
+        assert!(!lock4.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp).unwrap());
+
+        assert!(LockTime::ZERO
+            .is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp)
+            .unwrap());
+        assert!(LockTime::from_512_second_intervals(0)
+            .is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp)
+            .unwrap());
+
+        let lock6 = LockTime::from_seconds_floor(5000).unwrap();
+        assert!(lock6.is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp).unwrap());
+
+        let max_height_lock = LockTime::Blocks(NumberOfBlocks::MAX);
+        assert!(!max_height_lock
+            .is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp)
+            .unwrap());
+
+        let max_time_lock = LockTime::Time(NumberOf512Seconds::MAX);
+        assert!(!max_time_lock
+            .is_satisfied_by(chain_height, chain_mtp, utxo_height, utxo_mtp)
+            .unwrap());
+
+        let max_chain_height = BlockHeight::from_u32(u32::MAX);
+        let max_chain_mtp = BlockMtp::new(generate_timestamps(u32::MAX, 100));
+        let max_utxo_height = BlockHeight::MAX;
+        let max_utxo_mtp = max_chain_mtp;
+        assert!(!max_height_lock
+            .is_satisfied_by(max_chain_height, max_chain_mtp, max_utxo_height, max_utxo_mtp)
+            .unwrap());
+        assert!(!max_time_lock
+            .is_satisfied_by(max_chain_height, max_chain_mtp, max_utxo_height, max_utxo_mtp)
+            .unwrap());
+    }
+
+    #[test]
+    #[allow(deprecated_in_future)]
+    fn sanity_check() {
+        assert_eq!(LockTime::from(NumberOfBlocks::MAX).to_consensus_u32(), u32::from(u16::MAX));
+        assert_eq!(
+            NumberOf512Seconds::from_512_second_intervals(100).to_512_second_intervals(),
+            100u16
+        );
+        assert_eq!(
+            LockTime::from(NumberOf512Seconds::from_512_second_intervals(100)).to_consensus_u32(),
+            4_194_404u32
+        ); // 0x400064
+        assert_eq!(NumberOf512Seconds::from_512_second_intervals(1).to_seconds(), 512);
+    }
+
+    #[test]
+    fn from_512_second_intervals_roundtrip() {
+        let intervals = 100_u16;
+        let locktime = NumberOf512Seconds::from_512_second_intervals(intervals);
+        assert_eq!(locktime.to_512_second_intervals(), intervals);
+    }
+
+    #[test]
+    fn from_seconds_ceil_success() {
+        let actual = NumberOf512Seconds::from_seconds_ceil(100).unwrap();
+        let expected = NumberOf512Seconds(1_u16);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn from_seconds_ceil_with_maximum_encodable_seconds_success() {
+        let actual = NumberOf512Seconds::from_seconds_ceil(MAXIMUM_ENCODABLE_SECONDS).unwrap();
+        let expected = NumberOf512Seconds(u16::MAX);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn from_seconds_ceil_causes_time_overflow_error() {
+        let result = NumberOf512Seconds::from_seconds_ceil(MAXIMUM_ENCODABLE_SECONDS + 1);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn from_seconds_floor_success() {
+        let actual = NumberOf512Seconds::from_seconds_floor(100).unwrap();
+        let expected = NumberOf512Seconds(0_u16);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn from_seconds_floor_with_exact_interval() {
+        let actual = NumberOf512Seconds::from_seconds_floor(512).unwrap();
+        let expected = NumberOf512Seconds(1_u16);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn from_seconds_floor_with_maximum_encodable_seconds_success() {
+        let actual =
+            NumberOf512Seconds::from_seconds_floor(MAXIMUM_ENCODABLE_SECONDS + 511).unwrap();
+        let expected = NumberOf512Seconds(u16::MAX);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn from_seconds_floor_causes_time_overflow_error() {
+        let result = NumberOf512Seconds::from_seconds_floor(MAXIMUM_ENCODABLE_SECONDS + 512);
+        assert!(result.is_err());
+    }
+
+    fn generate_timestamps(start: u32, step: u16) -> [BlockTime; 11] {
+        let mut timestamps = [BlockTime::from_u32(0); 11];
+        for (i, ts) in timestamps.iter_mut().enumerate() {
+            *ts = BlockTime::from_u32(start.saturating_sub((step * i as u16).into()));
+        }
+        timestamps
+    }
+
+    #[test]
+    fn test_time_chain_state() {
+        use crate::BlockMtp;
+
+        let timestamps: [BlockTime; 11] = generate_timestamps(1_600_000_000, 200);
+        let utxo_timestamps: [BlockTime; 11] = generate_timestamps(1_599_000_000, 200);
+
+        let timestamps2: [BlockTime; 11] = generate_timestamps(1_599_995_119, 200);
+        let utxo_timestamps2: [BlockTime; 11] = generate_timestamps(1_599_990_000, 200);
+
+        let timestamps3: [BlockTime; 11] = generate_timestamps(1_600_050_000, 200);
+        let utxo_timestamps3: [BlockTime; 11] = generate_timestamps(1_599_990_000, 200);
+
+        // Test case 1: Satisfaction (current_mtp >= utxo_mtp + required_seconds)
+        // 10 intervals × 512 seconds = 5120 seconds
+        let time_lock = NumberOf512Seconds::from_512_second_intervals(10);
+        let chain_state1 = BlockMtp::new(timestamps);
+        let utxo_state1 = BlockMtp::new(utxo_timestamps);
+        assert!(time_lock.is_satisfied_by(chain_state1, utxo_state1).unwrap());
+
+        // Test case 2: Not satisfied (current_mtp < utxo_mtp + required_seconds)
+        let chain_state2 = BlockMtp::new(timestamps2);
+        let utxo_state2 = BlockMtp::new(utxo_timestamps2);
+        assert!(!time_lock.is_satisfied_by(chain_state2, utxo_state2).unwrap());
+
+        // Test case 3: Test with a larger value (100 intervals = 51200 seconds)
+        let larger_lock = NumberOf512Seconds::from_512_second_intervals(100);
+        let chain_state3 = BlockMtp::new(timestamps3);
+        let utxo_state3 = BlockMtp::new(utxo_timestamps3);
+        assert!(larger_lock.is_satisfied_by(chain_state3, utxo_state3).unwrap());
+
+        // Test case 4: Overflow handling - tests that is_satisfied_by handles overflow gracefully
+        let max_time_lock = NumberOf512Seconds::MAX;
+        let chain_state4 = BlockMtp::new(timestamps);
+        let utxo_state4 = BlockMtp::new(utxo_timestamps);
+        assert!(!max_time_lock.is_satisfied_by(chain_state4, utxo_state4).unwrap());
+    }
+
+    #[test]
+    fn test_height_chain_state() {
+        let height_lock = NumberOfBlocks(10);
+
+        // Test case 1: Satisfaction (current_height >= utxo_height + required)
+        let chain_state1 = BlockHeight::from_u32(89);
+        let utxo_state1 = BlockHeight::from_u32(80);
+        assert!(height_lock.is_satisfied_by(chain_state1, utxo_state1).unwrap());
+
+        // Test case 2: Not satisfied (current_height < utxo_height + required)
+        let chain_state2 = BlockHeight::from_u32(88);
+        let utxo_state2 = BlockHeight::from_u32(80);
+        assert!(!height_lock.is_satisfied_by(chain_state2, utxo_state2).unwrap());
+
+        // Test case 3: Overflow handling - tests that is_satisfied_by handles overflow gracefully
+        let max_height_lock = NumberOfBlocks::MAX;
+        let chain_state3 = BlockHeight::from_u32(1000);
+        let utxo_state3 = BlockHeight::from_u32(80);
+        assert!(!max_height_lock.is_satisfied_by(chain_state3, utxo_state3).unwrap());
+    }
+}
diff --git a/units/src/parse.rs b/units/src/parse_int.rs
similarity index 93%
rename from units/src/parse.rs
rename to units/src/parse_int.rs
index 502a4a1e7e..1c4591fe35 100644
--- a/units/src/parse.rs
+++ b/units/src/parse_int.rs
@@ -83,10 +83,10 @@ mod sealed {
 /// string is lost.
 ///
 /// If the caller has a `String` or `Box<str>` which is not used later it's better to call
-/// [`parse::int_from_string`] or [`parse::int_from_box`] respectively.
+/// [`parse_int::int_from_string`] or [`parse_int::int_from_box`] respectively.
 ///
-/// [`parse::int_from_string`]: crate::parse::int_from_string
-/// [`parse::int_from_box`]: crate::parse::int_from_box
+/// [`parse_int::int_from_string`]: crate::parse_int::int_from_string
+/// [`parse_int::int_from_box`]: crate::parse_int::int_from_box
 ///
 /// # Errors
 ///
@@ -143,17 +143,15 @@ fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, ParseIn
 ///
 /// * `to` - the type converted to e.g., `impl From<&str> for $to`.
 /// * `err` - the error type returned by `$inner_fn` (implies returned by `FromStr` and `TryFrom`).
-/// * `fn`: The infallible conversion function to call to convert from an integer.
+/// * `fn`: the infallible conversion function to call to convert from an integer.
 ///
 /// # Errors
 ///
 /// If parsing the string fails then a `units::parse::ParseIntError` is returned.
-#[macro_export]
-#[doc(hidden)] // This macro is stable but is considered internal to the `rust-bitcoin` repository.
 macro_rules! impl_parse_str_from_int_infallible {
     ($to:ident, $inner:ident, $fn:ident) => {
         impl $crate::_export::_core::str::FromStr for $to {
-            type Err = $crate::parse::ParseIntError;
+            type Err = $crate::parse_int::ParseIntError;
 
             fn from_str(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Err> {
                 $crate::_export::_core::convert::TryFrom::try_from(s)
@@ -161,36 +159,37 @@ macro_rules! impl_parse_str_from_int_infallible {
         }
 
         impl $crate::_export::_core::convert::TryFrom<&str> for $to {
-            type Error = $crate::parse::ParseIntError;
+            type Error = $crate::parse_int::ParseIntError;
 
             fn try_from(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                $crate::parse::int_from_str::<$inner>(s).map($to::$fn)
+                $crate::parse_int::int_from_str::<$inner>(s).map($to::$fn)
             }
         }
 
         #[cfg(feature = "alloc")]
         impl $crate::_export::_core::convert::TryFrom<alloc::string::String> for $to {
-            type Error = $crate::parse::ParseIntError;
+            type Error = $crate::parse_int::ParseIntError;
 
             fn try_from(
                 s: alloc::string::String,
             ) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                $crate::parse::int_from_string::<$inner>(s).map($to::$fn)
+                $crate::parse_int::int_from_string::<$inner>(s).map($to::$fn)
             }
         }
 
         #[cfg(feature = "alloc")]
         impl $crate::_export::_core::convert::TryFrom<alloc::boxed::Box<str>> for $to {
-            type Error = $crate::parse::ParseIntError;
+            type Error = $crate::parse_int::ParseIntError;
 
             fn try_from(
                 s: alloc::boxed::Box<str>,
             ) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                $crate::parse::int_from_box::<$inner>(s).map($to::$fn)
+                $crate::parse_int::int_from_box::<$inner>(s).map($to::$fn)
             }
         }
     };
 }
+pub(crate) use impl_parse_str_from_int_infallible;
 
 /// Implements standard parsing traits for `$type` by calling through to `$inner_fn`.
 ///
@@ -208,18 +207,16 @@ macro_rules! impl_parse_str_from_int_infallible {
 ///
 /// * `to` - the type converted to e.g., `impl From<&str> for $to`.
 /// * `err` - the error type returned by `$inner_fn` (implies returned by `FromStr` and `TryFrom`).
-/// * `inner_fn`: The fallible conversion function to call to convert from a string reference.
+/// * `inner_fn`: the fallible conversion function to call to convert from a string reference.
 ///
 /// # Errors
 ///
 /// All functions use the error returned by `$inner_fn`.
-#[macro_export]
-#[doc(hidden)] // This macro is stable but is considered internal to the `rust-bitcoin` repository.
 macro_rules! impl_parse_str {
     ($to:ty, $err:ty, $inner_fn:expr) => {
-        $crate::impl_tryfrom_str!(&str, $to, $err, $inner_fn);
+        $crate::parse_int::impl_tryfrom_str!(&str, $to, $err, $inner_fn);
         #[cfg(feature = "alloc")]
-        $crate::impl_tryfrom_str!(alloc::string::String, $to, $err, $inner_fn; alloc::boxed::Box<str>, $to, $err, $inner_fn);
+        $crate::parse_int::impl_tryfrom_str!(alloc::string::String, $to, $err, $inner_fn; alloc::boxed::Box<str>, $to, $err, $inner_fn);
 
         impl $crate::_export::_core::str::FromStr for $to {
             type Err = $err;
@@ -230,10 +227,9 @@ macro_rules! impl_parse_str {
         }
     }
 }
+pub(crate) use impl_parse_str;
 
 /// Implements `TryFrom<$from> for $to`.
-#[macro_export]
-#[doc(hidden)] // Helper macro called by `impl_parse_str`.
 macro_rules! impl_tryfrom_str {
     ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
         $(
@@ -247,6 +243,7 @@ macro_rules! impl_tryfrom_str {
         )*
     }
 }
+pub(crate) use impl_tryfrom_str;
 
 /// Removes the prefix `0x` (or `0X`) from a hex string.
 ///
@@ -552,11 +549,11 @@ mod tests {
             type Err = core::num::ParseIntError;
 
             fn from_str(_: &str) -> Result<Self, Self::Err> {
-                "Always invalid for testing".parse::<u32>().map(|_| TestTypeLargerThanU128(0, 0))
+                "Always invalid for testing".parse::<u32>().map(|_| Self(0, 0))
             }
         }
         impl From<i8> for TestTypeLargerThanU128 {
-            fn from(_: i8) -> Self { TestTypeLargerThanU128(0, 0) }
+            fn from(_: i8) -> Self { Self(0, 0) }
         }
 
         let result = panic::catch_unwind(|| int_from_str::<TestTypeLargerThanU128>("not a number"));
diff --git a/units/src/result.rs b/units/src/result.rs
index dcc714deaa..2c1881d304 100644
--- a/units/src/result.rs
+++ b/units/src/result.rs
@@ -3,8 +3,10 @@
 //! Provides a monodic type returned by mathematical operations (`core::ops`).
 
 use core::convert::Infallible;
-use core::fmt;
+use core::{fmt, ops};
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 use NumOpResult as R;
 
 use crate::{Amount, FeeRate, SignedAmount, Weight};
@@ -53,12 +55,12 @@ use crate::{Amount, FeeRate, SignedAmount, Weight};
 /// In some instances one may wish to differentiate div-by-zero from overflow.
 ///
 /// ```
-/// # use bitcoin_units::{Amount, FeeRate, NumOpResult, NumOpError};
+/// # use bitcoin_units::{Amount, FeeRate, NumOpResult, result::NumOpError};
 /// // Two amounts that will be added to calculate the max fee.
 /// let a = Amount::from_sat(123).expect("valid amount");
 /// let b = Amount::from_sat(467).expect("valid amount");
 /// // Fee rate for transaction.
-/// let fee_rate = FeeRate::from_sat_per_vb(1).unwrap();
+/// let fee_rate = FeeRate::from_sat_per_vb(1);
 ///
 /// // Somewhat contrived example to show addition operator chained with division.
 /// let max_fee = a + b;
@@ -90,28 +92,11 @@ pub enum NumOpResult<T> {
 impl<T> NumOpResult<T> {
     /// Maps a `NumOpResult<T>` to `NumOpResult<U>` by applying a function to a
     /// contained [`NumOpResult::Valid`] value, leaving a [`NumOpResult::Error`] value untouched.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bitcoin_units::{FeeRate, Amount, Weight, SignedAmount};
-    ///
-    /// let fee_rate = FeeRate::from_sat_per_vb(1).unwrap();
-    /// let weight = Weight::from_wu(1000);
-    /// let amount = Amount::from_sat_u32(1_000_000);
-    ///
-    /// let amount_after_fee = fee_rate
-    ///     .to_fee(weight) // (1 sat/ 4 wu) * (1000 wu) = 250 sat fee
-    ///     .map(|fee| fee.to_signed())
-    ///     .and_then(|fee| amount.to_signed() - fee);
-    ///
-    /// assert_eq!(amount_after_fee.unwrap(), SignedAmount::from_sat_i32(999_750))
-    /// ```
     #[inline]
     pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> NumOpResult<U> {
         match self {
-            NumOpResult::Valid(t) => NumOpResult::Valid(op(t)),
-            NumOpResult::Error(e) => NumOpResult::Error(e),
+            Self::Valid(t) => NumOpResult::Valid(op(t)),
+            Self::Error(e) => NumOpResult::Error(e),
         }
     }
 }
@@ -126,8 +111,8 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[track_caller]
     pub fn expect(self, msg: &str) -> T {
         match self {
-            R::Valid(x) => x,
-            R::Error(_) => panic!("{}", msg),
+            Self::Valid(x) => x,
+            Self::Error(_) => panic!("{}", msg),
         }
     }
 
@@ -140,8 +125,8 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[track_caller]
     pub fn unwrap(self) -> T {
         match self {
-            R::Valid(x) => x,
-            R::Error(e) => panic!("tried to unwrap an invalid numeric result: {:?}", e),
+            Self::Valid(x) => x,
+            Self::Error(e) => panic!("tried to unwrap an invalid numeric result: {:?}", e),
         }
     }
 
@@ -154,8 +139,34 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[track_caller]
     pub fn unwrap_err(self) -> NumOpError {
         match self {
-            R::Error(e) => e,
-            R::Valid(a) => panic!("tried to unwrap a valid numeric result: {:?}", a),
+            Self::Error(e) => e,
+            Self::Valid(a) => panic!("tried to unwrap a valid numeric result: {:?}", a),
+        }
+    }
+
+    /// Returns the contained Some value or a provided default.
+    ///
+    /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing the result of a
+    /// function call, it is recommended to use `unwrap_or_else`, which is lazily evaluated.
+    #[inline]
+    #[track_caller]
+    pub fn unwrap_or(self, default: T) -> T {
+        match self {
+            Self::Valid(x) => x,
+            Self::Error(_) => default,
+        }
+    }
+
+    /// Returns the contained `Some` value or computes it from a closure.
+    #[inline]
+    #[track_caller]
+    pub fn unwrap_or_else<F>(self, f: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
+        match self {
+            Self::Valid(x) => x,
+            Self::Error(_) => f(),
         }
     }
 
@@ -163,8 +174,8 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[inline]
     pub fn ok(self) -> Option<T> {
         match self {
-            R::Valid(x) => Some(x),
-            R::Error(_) => None,
+            Self::Valid(x) => Some(x),
+            Self::Error(_) => None,
         }
     }
 
@@ -173,20 +184,20 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[allow(clippy::missing_errors_doc)]
     pub fn into_result(self) -> Result<T, NumOpError> {
         match self {
-            R::Valid(x) => Ok(x),
-            R::Error(e) => Err(e),
+            Self::Valid(x) => Ok(x),
+            Self::Error(e) => Err(e),
         }
     }
 
     /// Calls `op` if the numeric result is `Valid`, otherwise returns the `Error` value of `self`.
     #[inline]
-    pub fn and_then<F>(self, op: F) -> NumOpResult<T>
+    pub fn and_then<F>(self, op: F) -> Self
     where
-        F: FnOnce(T) -> NumOpResult<T>,
+        F: FnOnce(T) -> Self,
     {
         match self {
-            R::Valid(x) => op(x),
-            R::Error(e) => R::Error(e),
+            Self::Valid(x) => op(x),
+            Self::Error(e) => Self::Error(e),
         }
     }
 
@@ -194,8 +205,8 @@ impl<T: fmt::Debug> NumOpResult<T> {
     #[inline]
     pub fn is_valid(&self) -> bool {
         match self {
-            R::Valid(_) => true,
-            R::Error(_) => false,
+            Self::Valid(_) => true,
+            Self::Error(_) => false,
         }
     }
 
@@ -204,6 +215,96 @@ impl<T: fmt::Debug> NumOpResult<T> {
     pub fn is_error(&self) -> bool { !self.is_valid() }
 }
 
+// Implement Add/Sub on NumOpResults for all wrapped types that already implement Add/Sub on themselves
+crate::internal_macros::impl_op_for_references! {
+    impl<T> ops::Add<NumOpResult<T>> for NumOpResult<T>
+    where
+        (T: Copy + ops::Add<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
+
+        fn add(self, rhs: Self) -> Self::Output {
+            match (self, rhs) {
+                (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+                (_, _) => R::Error(NumOpError::while_doing(MathOp::Add)),
+            }
+        }
+    }
+
+    impl<T> ops::Add<T> for NumOpResult<T>
+    where
+        (T: Copy + ops::Add<NumOpResult<T>, Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
+
+        fn add(self, rhs: T) -> Self::Output { rhs + self }
+    }
+
+    impl<T> ops::Sub<NumOpResult<T>> for NumOpResult<T>
+    where
+        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
+
+        fn sub(self, rhs: Self) -> Self::Output {
+            match (self, rhs) {
+                (R::Valid(lhs), R::Valid(rhs)) => lhs - rhs,
+                (_, _) => R::Error(NumOpError::while_doing(MathOp::Sub)),
+            }
+        }
+    }
+
+    impl<T> ops::Sub<T> for NumOpResult<T>
+    where
+        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
+
+        fn sub(self, rhs: T) -> Self::Output {
+            match self {
+                R::Valid(amount) => amount - rhs,
+                R::Error(_) => self,
+            }
+        }
+    }
+}
+
+// Implement AddAssign on NumOpResults for all wrapped types that already implement AddAssign on themselves
+impl<T: ops::AddAssign> ops::AddAssign<T> for NumOpResult<T> {
+    fn add_assign(&mut self, rhs: T) {
+        if let Self::Valid(ref mut lhs) = self {
+            *lhs += rhs;
+        }
+    }
+}
+
+impl<T: ops::AddAssign + Copy> ops::AddAssign<Self> for NumOpResult<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        match (&self, rhs) {
+            (Self::Valid(_), Self::Valid(rhs)) => *self += rhs,
+            (_, _) => *self = Self::Error(NumOpError::while_doing(MathOp::Add)),
+        }
+    }
+}
+
+// Implement SubAssign on NumOpResults for all wrapped types that already implement SubAssign on themselves
+impl<T: ops::SubAssign> ops::SubAssign<T> for NumOpResult<T> {
+    fn sub_assign(&mut self, rhs: T) {
+        if let Self::Valid(ref mut lhs) = self {
+            *lhs -= rhs;
+        }
+    }
+}
+
+impl<T: ops::SubAssign + Copy> ops::SubAssign<Self> for NumOpResult<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        match (&self, rhs) {
+            (Self::Valid(_), Self::Valid(rhs)) => *self -= rhs,
+            (_, _) => *self = Self::Error(NumOpError::while_doing(MathOp::Sub)),
+        }
+    }
+}
+
 pub(crate) trait OptionExt<T> {
     fn valid_or_error(self, op: MathOp) -> NumOpResult<T>;
 }
@@ -231,8 +332,8 @@ impl_opt_ext!(Amount, SignedAmount, u64, i64, FeeRate, Weight);
 pub struct NumOpError(MathOp);
 
 impl NumOpError {
-    /// Creates a [`NumOpError`] caused by `op`.
-    pub(crate) const fn while_doing(op: MathOp) -> Self { NumOpError(op) }
+    /// Constructs a [`NumOpError`] caused by `op`.
+    pub(crate) const fn while_doing(op: MathOp) -> Self { Self(op) }
 
     /// Returns `true` if this operation error'ed due to overflow.
     pub fn is_overflow(self) -> bool { self.0.is_overflow() }
@@ -278,35 +379,91 @@ pub enum MathOp {
 impl MathOp {
     /// Returns `true` if this operation error'ed due to overflow.
     pub fn is_overflow(self) -> bool {
-        matches!(self, MathOp::Add | MathOp::Sub | MathOp::Mul | MathOp::Neg)
+        matches!(self, Self::Add | Self::Sub | Self::Mul | Self::Neg)
     }
 
     /// Returns `true` if this operation error'ed due to division by zero.
     pub fn is_div_by_zero(self) -> bool { !self.is_overflow() }
 
     /// Returns `true` if this operation error'ed due to addition.
-    pub fn is_addition(self) -> bool { self == MathOp::Add }
+    pub fn is_addition(self) -> bool { self == Self::Add }
 
     /// Returns `true` if this operation error'ed due to subtraction.
-    pub fn is_subtraction(self) -> bool { self == MathOp::Sub }
+    pub fn is_subtraction(self) -> bool { self == Self::Sub }
 
     /// Returns `true` if this operation error'ed due to multiplication.
-    pub fn is_multiplication(self) -> bool { self == MathOp::Mul }
+    pub fn is_multiplication(self) -> bool { self == Self::Mul }
 
     /// Returns `true` if this operation error'ed due to negation.
-    pub fn is_negation(self) -> bool { self == MathOp::Neg }
+    pub fn is_negation(self) -> bool { self == Self::Neg }
 }
 
 impl fmt::Display for MathOp {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            MathOp::Add => write!(f, "add"),
-            MathOp::Sub => write!(f, "sub"),
-            MathOp::Mul => write!(f, "mul"),
-            MathOp::Div => write!(f, "div"),
-            MathOp::Rem => write!(f, "rem"),
-            MathOp::Neg => write!(f, "neg"),
-            MathOp::_DoNotUse(infallible) => match infallible {},
+            Self::Add => write!(f, "add"),
+            Self::Sub => write!(f, "sub"),
+            Self::Mul => write!(f, "mul"),
+            Self::Div => write!(f, "div"),
+            Self::Rem => write!(f, "rem"),
+            Self::Neg => write!(f, "neg"),
+            Self::_DoNotUse(infallible) => match infallible {},
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a, T: Arbitrary<'a>> Arbitrary<'a> for NumOpResult<T> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        match bool::arbitrary(u)? {
+            true => Ok(Self::Valid(T::arbitrary(u)?)),
+            false => Ok(Self::Error(NumOpError(MathOp::arbitrary(u)?))),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for MathOp {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=5)?;
+        match choice {
+            0 => Ok(Self::Add),
+            1 => Ok(Self::Sub),
+            2 => Ok(Self::Mul),
+            3 => Ok(Self::Div),
+            4 => Ok(Self::Rem),
+            _ => Ok(Self::Neg),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::result::MathOp;
+
+    #[test]
+    fn mathop_predicates() {
+        assert!(MathOp::Add.is_overflow());
+        assert!(MathOp::Sub.is_overflow());
+        assert!(MathOp::Mul.is_overflow());
+        assert!(MathOp::Neg.is_overflow());
+        assert!(!MathOp::Div.is_overflow());
+        assert!(!MathOp::Rem.is_overflow());
+
+        assert!(MathOp::Div.is_div_by_zero());
+        assert!(MathOp::Rem.is_div_by_zero());
+        assert!(!MathOp::Add.is_div_by_zero());
+
+        assert!(MathOp::Add.is_addition());
+        assert!(!MathOp::Sub.is_addition());
+
+        assert!(MathOp::Sub.is_subtraction());
+        assert!(!MathOp::Add.is_subtraction());
+
+        assert!(MathOp::Mul.is_multiplication());
+        assert!(!MathOp::Div.is_multiplication());
+
+        assert!(MathOp::Neg.is_negation());
+        assert!(!MathOp::Add.is_negation());
+    }
+}
diff --git a/primitives/src/sequence.rs b/units/src/sequence.rs
similarity index 58%
rename from primitives/src/sequence.rs
rename to units/src/sequence.rs
index 7d68c7cdf0..12ff197e16 100644
--- a/primitives/src/sequence.rs
+++ b/units/src/sequence.rs
@@ -3,29 +3,31 @@
 //! Bitcoin transaction input sequence number.
 //!
 //! The sequence field is used for:
-//! - Indicating whether absolute lock-time (specified in `lock_time` field of [`Transaction`]) is enabled.
-//! - Indicating and encoding [BIP-68] relative lock-times.
-//! - Indicating whether a transaction opts-in to [BIP-125] replace-by-fee.
+//! - Indicating whether absolute lock-time (specified in `lock_time` field of `Transaction`) is enabled.
+//! - Indicating and encoding [BIP-0068] relative lock-times.
+//! - Indicating whether a transaction opts-in to [BIP-0125] replace-by-fee.
 //!
-//! Note that transactions spending an output with `OP_CHECKLOCKTIMEVERIFY`MUST NOT use
-//! `Sequence::MAX` for the corresponding input. [BIP-65]
+//! Note that transactions spending an output with `OP_CHECKLOCKTIMEVERIFY` MUST NOT use
+//! `Sequence::MAX` for the corresponding input. [BIP-0065]
 //!
-//! [BIP-65]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
-//! [BIP-68]: <https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki>
-//! [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
+//! [BIP-0065]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
+//! [BIP-0068]: <https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki>
+//! [BIP-0125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
 
+#[cfg(feature = "encoding")]
+use core::convert::Infallible;
 use core::fmt;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+#[cfg(feature = "encoding")]
+use internals::write_err;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use units::locktime::relative::TimeOverflowError;
-use units::parse::{self, PrefixedHexError, UnprefixedHexError};
 
-use crate::locktime::relative;
-#[cfg(all(doc, feature = "alloc"))]
-use crate::transaction::Transaction;
+use crate::locktime::relative::error::TimeOverflowError;
+use crate::locktime::relative::{self, NumberOf512Seconds};
+use crate::parse_int::{self, PrefixedHexError, UnprefixedHexError};
 
 /// Bitcoin transaction input sequence number.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -36,25 +38,25 @@ impl Sequence {
     /// The maximum allowable sequence number.
     ///
     /// The sequence number that disables replace-by-fee, absolute lock time and relative lock time.
-    pub const MAX: Self = Sequence(0xFFFF_FFFF);
+    pub const MAX: Self = Self(0xFFFF_FFFF);
     /// Zero value sequence.
     ///
     /// This sequence number enables replace-by-fee and absolute lock time.
-    pub const ZERO: Self = Sequence(0);
+    pub const ZERO: Self = Self(0);
     /// The sequence number that disables replace-by-fee, absolute lock time and relative lock time.
-    pub const FINAL: Self = Sequence::MAX;
+    pub const FINAL: Self = Self::MAX;
     /// The sequence number that enables absolute lock time but disables replace-by-fee
     /// and relative lock time.
-    pub const ENABLE_LOCKTIME_NO_RBF: Self = Sequence::MIN_NO_RBF;
+    pub const ENABLE_LOCKTIME_NO_RBF: Self = Self::MIN_NO_RBF;
     /// The sequence number that enables replace-by-fee and absolute lock time but
     /// disables relative lock time.
-    #[deprecated(since = "TBD", note = "use `ENABLE_LOCKTIME_AND_RBF` instead")]
-    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFF_FFFD);
+    #[deprecated(since = "1.0.0-rc.0", note = "use `ENABLE_LOCKTIME_AND_RBF` instead")]
+    pub const ENABLE_RBF_NO_LOCKTIME: Self = Self(0xFFFF_FFFD);
     /// The maximum sequence number that enables replace-by-fee and absolute lock time but
     /// disables relative lock time.
     ///
     /// This sequence number has no meaning other than to enable RBF and the absolute locktime.
-    pub const ENABLE_LOCKTIME_AND_RBF: Self = Sequence(0xFFFF_FFFD);
+    pub const ENABLE_LOCKTIME_AND_RBF: Self = Self(0xFFFF_FFFD);
 
     /// The number of bytes that a sequence number contributes to the size of a transaction.
     pub const SIZE: usize = 4; // Serialized length of a u32.
@@ -62,19 +64,19 @@ impl Sequence {
     /// The lowest sequence number that does not opt-in for replace-by-fee.
     ///
     /// A transaction is considered to have opted in to replacement of itself
-    /// if any of it's inputs have a `Sequence` number less than this value
-    /// (Explicit Signalling [BIP-125]).
+    /// if any of its inputs have a `Sequence` number less than this value
+    /// (Explicit Signalling [BIP-0125]).
     ///
-    /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki]>
-    const MIN_NO_RBF: Self = Sequence(0xFFFF_FFFE);
-    /// BIP-68 relative lock time disable flag mask.
+    /// [BIP-0125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
+    const MIN_NO_RBF: Self = Self(0xFFFF_FFFE);
+    /// BIP-0068 relative lock time disable flag mask.
     const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x8000_0000;
-    /// BIP-68 relative lock time type flag mask.
+    /// BIP-0068 relative lock time type flag mask.
     pub(super) const LOCK_TYPE_MASK: u32 = 0x0040_0000;
 
-    /// Returns `true` if the sequence number enables absolute lock-time ([`Transaction::lock_time`]).
+    /// Returns `true` if the sequence number enables absolute lock-time (`Transaction::lock_time`).
     #[inline]
-    pub fn enables_absolute_lock_time(self) -> bool { self != Sequence::MAX }
+    pub fn enables_absolute_lock_time(self) -> bool { self != Self::MAX }
 
     /// Returns `true` if the sequence number indicates that the transaction is finalized.
     ///
@@ -91,55 +93,63 @@ impl Sequence {
     ///
     /// Some other references to the term:
     /// - `CTxIn::SEQUENCE_FINAL` in the Bitcoin Core code.
-    /// - [BIP-112]: "BIP 68 prevents a non-final transaction from being selected for inclusion in a
+    /// - [BIP-0112]: "BIP-0068 prevents a non-final transaction from being selected for inclusion in a
     ///   block until the corresponding input has reached the specified age"
     ///
-    /// [BIP-112]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
+    /// [BIP-0112]: <https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki>
     #[inline]
     pub fn is_final(self) -> bool { !self.enables_absolute_lock_time() }
 
-    /// Returns true if the transaction opted-in to BIP125 replace-by-fee.
+    /// Returns true if the transaction opted-in to BIP-0125 replace-by-fee.
     ///
     /// Replace by fee is signaled by the sequence being less than 0xfffffffe which is checked by
     /// this method. Note, this is the highest "non-final" value (see [`Sequence::is_final`]).
     #[inline]
-    pub fn is_rbf(self) -> bool { self < Sequence::MIN_NO_RBF }
+    pub fn is_rbf(self) -> bool { self < Self::MIN_NO_RBF }
 
     /// Returns `true` if the sequence has a relative lock-time.
     #[inline]
-    pub fn is_relative_lock_time(self) -> bool {
-        self.0 & Sequence::LOCK_TIME_DISABLE_FLAG_MASK == 0
-    }
+    pub fn is_relative_lock_time(self) -> bool { self.0 & Self::LOCK_TIME_DISABLE_FLAG_MASK == 0 }
 
     /// Returns `true` if the sequence number encodes a block based relative lock-time.
     #[inline]
     pub fn is_height_locked(self) -> bool {
-        self.is_relative_lock_time() & (self.0 & Sequence::LOCK_TYPE_MASK == 0)
+        self.is_relative_lock_time() & (self.0 & Self::LOCK_TYPE_MASK == 0)
     }
 
     /// Returns `true` if the sequence number encodes a time interval based relative lock-time.
     #[inline]
     pub fn is_time_locked(self) -> bool {
-        self.is_relative_lock_time() & (self.0 & Sequence::LOCK_TYPE_MASK > 0)
+        self.is_relative_lock_time() & (self.0 & Self::LOCK_TYPE_MASK > 0)
     }
 
     /// Constructs a new `Sequence` from a prefixed hex string.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a locktime or it does not include
+    /// the `0x` prefix.
     #[inline]
     pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
-        let lock_time = parse::hex_u32_prefixed(s)?;
+        let lock_time = parse_int::hex_u32_prefixed(s)?;
         Ok(Self::from_consensus(lock_time))
     }
 
     /// Constructs a new `Sequence` from an unprefixed hex string.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a locktime or if it includes the
+    /// `0x` prefix.
     #[inline]
     pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
-        let lock_time = parse::hex_u32_unprefixed(s)?;
+        let lock_time = parse_int::hex_u32_unprefixed(s)?;
         Ok(Self::from_consensus(lock_time))
     }
 
     /// Constructs a new relative lock-time using block height.
     #[inline]
-    pub fn from_height(height: u16) -> Self { Sequence(u32::from(height)) }
+    pub fn from_height(height: u16) -> Self { Self(u32::from(height)) }
 
     /// Constructs a new relative lock-time using time intervals where each interval is equivalent
     /// to 512 seconds.
@@ -147,47 +157,57 @@ impl Sequence {
     /// Encoding finer granularity of time for relative lock-times is not supported in Bitcoin
     #[inline]
     pub fn from_512_second_intervals(intervals: u16) -> Self {
-        Sequence(u32::from(intervals) | Sequence::LOCK_TYPE_MASK)
+        Self(u32::from(intervals) | Self::LOCK_TYPE_MASK)
     }
 
     /// Constructs a new relative lock-time from seconds, converting the seconds into 512 second
     /// interval with floor division.
     ///
     /// Will return an error if the input cannot be encoded in 16 bits.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if `seconds` cannot be encoded in 16 bits. See
+    /// [`NumberOf512Seconds::from_seconds_floor`].
     #[inline]
     pub fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
-        if let Ok(interval) = u16::try_from(seconds / 512) {
-            Ok(Sequence::from_512_second_intervals(interval))
-        } else {
-            Err(TimeOverflowError::new(seconds))
-        }
+        let intervals = NumberOf512Seconds::from_seconds_floor(seconds)?;
+        Ok(Self::from_512_second_intervals(intervals.to_512_second_intervals()))
     }
 
     /// Constructs a new relative lock-time from seconds, converting the seconds into 512 second
     /// interval with ceiling division.
     ///
     /// Will return an error if the input cannot be encoded in 16 bits.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if `seconds` cannot be encoded in 16 bits. See
+    /// [`NumberOf512Seconds::from_seconds_ceil`].
     #[inline]
     pub fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
-        if let Ok(interval) = u16::try_from((seconds + 511) / 512) {
-            Ok(Sequence::from_512_second_intervals(interval))
-        } else {
-            Err(TimeOverflowError::new(seconds))
-        }
+        let intervals = NumberOf512Seconds::from_seconds_ceil(seconds)?;
+        Ok(Self::from_512_second_intervals(intervals.to_512_second_intervals()))
     }
 
     /// Constructs a new sequence from a u32 value.
     #[inline]
-    pub fn from_consensus(n: u32) -> Self { Sequence(n) }
+    pub fn from_consensus(n: u32) -> Self { Self(n) }
 
     /// Returns the inner 32bit integer value of Sequence.
     #[inline]
-    pub fn to_consensus_u32(self) -> u32 { self.0 }
+    pub const fn to_consensus_u32(self) -> u32 { self.0 }
+
+    /// Gets the hex representation of this [`Sequence`].
+    #[cfg(feature = "alloc")]
+    #[inline]
+    #[deprecated(since = "1.0.0-rc.0", note = "use `format!(\"{var:x}\")` instead")]
+    pub fn to_hex(self) -> alloc::string::String { alloc::format!("{:x}", self) }
 
     /// Constructs a new [`relative::LockTime`] from this [`Sequence`] number.
     #[inline]
     pub fn to_relative_lock_time(self) -> Option<relative::LockTime> {
-        use crate::locktime::relative::{LockTime, NumberOf512Seconds, NumberOfBlocks};
+        use crate::locktime::relative::{LockTime, NumberOfBlocks};
 
         if !self.is_relative_lock_time() {
             return None;
@@ -204,20 +224,20 @@ impl Sequence {
 
     /// Returns the low 16 bits from sequence number.
     ///
-    /// BIP-68 only uses the low 16 bits for relative lock value.
+    /// BIP-0068 only uses the low 16 bits for relative lock value.
     #[inline]
-    fn low_u16(self) -> u16 { self.0 as u16 }
+    const fn low_u16(self) -> u16 { self.0 as u16 }
 }
 
 impl Default for Sequence {
     /// The default value of sequence is 0xffffffff.
     #[inline]
-    fn default() -> Self { Sequence::MAX }
+    fn default() -> Self { Self::MAX }
 }
 
 impl From<Sequence> for u32 {
     #[inline]
-    fn from(sequence: Sequence) -> u32 { sequence.0 }
+    fn from(sequence: Sequence) -> Self { sequence.0 }
 }
 
 impl fmt::Display for Sequence {
@@ -229,10 +249,6 @@ impl fmt::LowerHex for Sequence {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
 }
-#[cfg(feature = "alloc")]
-internals::impl_to_hex_from_lower_hex!(Sequence, |sequence: &Sequence| {
-    8 - sequence.0.leading_zeros() as usize / 4
-});
 
 impl fmt::UpperHex for Sequence {
     #[inline]
@@ -248,7 +264,86 @@ impl fmt::Debug for Sequence {
 }
 
 #[cfg(feature = "alloc")]
-units::impl_parse_str_from_int_infallible!(Sequence, u32, from_consensus);
+parse_int::impl_parse_str_from_int_infallible!(Sequence, u32, from_consensus);
+
+#[cfg(feature = "encoding")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`Sequence`] type.
+    pub struct SequenceEncoder(encoding::ArrayEncoder<4>);
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Encodable for Sequence {
+    type Encoder<'e> = SequenceEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        SequenceEncoder(encoding::ArrayEncoder::without_length_prefix(
+            self.to_consensus_u32().to_le_bytes(),
+        ))
+    }
+}
+
+/// The decoder for the [`Sequence`] type.
+#[cfg(feature = "encoding")]
+pub struct SequenceDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl Default for SequenceDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "encoding")]
+impl SequenceDecoder {
+    /// Constructs a new [`Sequence`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for SequenceDecoder {
+    type Output = Sequence;
+    type Error = SequenceDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(SequenceDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end().map_err(SequenceDecoderError)?);
+        Ok(Sequence::from_consensus(n))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for Sequence {
+    type Decoder = SequenceDecoder;
+    fn decoder() -> Self::Decoder { SequenceDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `Sequence`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SequenceDecoderError(encoding::UnexpectedEofError);
+
+#[cfg(feature = "encoding")]
+impl From<Infallible> for SequenceDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "encoding")]
+impl fmt::Display for SequenceDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "sequence decoder error"; self.0)
+    }
+}
+
+#[cfg(all(feature = "std", feature = "encoding"))]
+impl std::error::Error for SequenceDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
 
 #[cfg(feature = "arbitrary")]
 #[cfg(feature = "alloc")]
@@ -257,21 +352,21 @@ impl<'a> Arbitrary<'a> for Sequence {
         // Equally weight the cases of meaningful sequence numbers
         let choice = u.int_in_range(0..=8)?;
         match choice {
-            0 => Ok(Sequence::MAX),
-            1 => Ok(Sequence::ZERO),
-            2 => Ok(Sequence::MIN_NO_RBF),
-            3 => Ok(Sequence::ENABLE_LOCKTIME_AND_RBF),
-            4 => Ok(Sequence::from_consensus(u32::from(relative::NumberOfBlocks::MIN.to_height()))),
-            5 => Ok(Sequence::from_consensus(u32::from(relative::NumberOfBlocks::MAX.to_height()))),
-            6 => Ok(Sequence::from_consensus(
-                Sequence::LOCK_TYPE_MASK
+            0 => Ok(Self::MAX),
+            1 => Ok(Self::ZERO),
+            2 => Ok(Self::MIN_NO_RBF),
+            3 => Ok(Self::ENABLE_LOCKTIME_AND_RBF),
+            4 => Ok(Self::from_consensus(u32::from(relative::NumberOfBlocks::MIN.to_height()))),
+            5 => Ok(Self::from_consensus(u32::from(relative::NumberOfBlocks::MAX.to_height()))),
+            6 => Ok(Self::from_consensus(
+                Self::LOCK_TYPE_MASK
                     | u32::from(relative::NumberOf512Seconds::MIN.to_512_second_intervals()),
             )),
-            7 => Ok(Sequence::from_consensus(
-                Sequence::LOCK_TYPE_MASK
+            7 => Ok(Self::from_consensus(
+                Self::LOCK_TYPE_MASK
                     | u32::from(relative::NumberOf512Seconds::MAX.to_512_second_intervals()),
             )),
-            _ => Ok(Sequence(u.arbitrary()?)),
+            _ => Ok(Self(u.arbitrary()?)),
         }
     }
 }
@@ -295,6 +390,8 @@ impl<'a> Arbitrary<'a> for Sequence {
 #[cfg(test)]
 #[cfg(feature = "alloc")]
 mod tests {
+    use alloc::format;
+
     use super::*;
 
     const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;
@@ -351,6 +448,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn sequence_formatting() {
         let sequence = Sequence(0x7FFF_FFFF);
         assert_eq!(format!("{:x}", sequence), "7fffffff");
@@ -362,7 +460,10 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "alloc")]
     fn sequence_display() {
+        use alloc::string::ToString;
+
         let sequence = Sequence(0x7FFF_FFFF);
         let want: u32 = 0x7FFF_FFFF;
         assert_eq!(format!("{}", sequence), want.to_string());
diff --git a/units/src/time.rs b/units/src/time.rs
index c58c3ae695..a16b3906d3 100644
--- a/units/src/time.rs
+++ b/units/src/time.rs
@@ -7,8 +7,15 @@
 //! This differs from other UNIX timestamps in that we only use non-negative values. The Epoch
 //! pre-dates Bitcoin so timestamps before this are not useful for block timestamps.
 
+#[cfg(feature = "encoding")]
+use core::convert::Infallible;
+#[cfg(feature = "encoding")]
+use core::fmt;
+
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+#[cfg(feature = "encoding")]
+use internals::write_err;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
@@ -31,7 +38,7 @@ mod encapsulate {
     impl BlockTime {
         /// Constructs a new [`BlockTime`] from an unsigned 32 bit integer value.
         #[inline]
-        pub const fn from_u32(t: u32) -> Self { BlockTime(t) }
+        pub const fn from_u32(t: u32) -> Self { Self(t) }
 
         /// Returns the inner `u32` value.
         #[inline]
@@ -73,17 +80,99 @@ impl<'de> Deserialize<'de> for BlockTime {
     }
 }
 
+#[cfg(feature = "encoding")]
+encoding::encoder_newtype! {
+    /// The encoder for the [`BlockTime`] type.
+    pub struct BlockTimeEncoder(encoding::ArrayEncoder<4>);
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Encodable for BlockTime {
+    type Encoder<'e> = BlockTimeEncoder;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        BlockTimeEncoder(encoding::ArrayEncoder::without_length_prefix(self.to_u32().to_le_bytes()))
+    }
+}
+
+/// The decoder for the [`BlockTime`] type.
+#[cfg(feature = "encoding")]
+pub struct BlockTimeDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl Default for BlockTimeDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+#[cfg(feature = "encoding")]
+impl BlockTimeDecoder {
+    /// Constructs a new [`BlockTime`] decoder.
+    pub const fn new() -> Self { Self(encoding::ArrayDecoder::new()) }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for BlockTimeDecoder {
+    type Output = BlockTime;
+    type Error = BlockTimeDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes).map_err(BlockTimeDecoderError)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let t = u32::from_le_bytes(self.0.end().map_err(BlockTimeDecoderError)?);
+        Ok(BlockTime::from_u32(t))
+    }
+
+    #[inline]
+    fn read_limit(&self) -> usize { self.0.read_limit() }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for BlockTime {
+    type Decoder = BlockTimeDecoder;
+    fn decoder() -> Self::Decoder { BlockTimeDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
+/// An error consensus decoding an `BlockTime`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockTimeDecoderError(encoding::UnexpectedEofError);
+
+#[cfg(feature = "encoding")]
+impl From<Infallible> for BlockTimeDecoderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+#[cfg(feature = "encoding")]
+impl fmt::Display for BlockTimeDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "block time decoder error"; self.0)
+    }
+}
+
+#[cfg(all(feature = "std", feature = "encoding"))]
+impl std::error::Error for BlockTimeDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockTime {
     #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let t: u32 = u.arbitrary()?;
-        Ok(BlockTime::from(t))
+        Ok(Self::from(t))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    #[cfg(all(feature = "encoding", feature = "alloc"))]
+    use encoding::UnexpectedEofError;
+    #[cfg(feature = "encoding")]
+    use encoding::{Decodable as _, Decoder as _};
+
     use super::*;
 
     #[test]
@@ -91,4 +180,56 @@ mod tests {
         let t = BlockTime::from(1_742_979_600); // 26 Mar 2025 9:00 UTC
         assert_eq!(u32::from(t), 1_742_979_600);
     }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn block_time_serde_round_trip() {
+        let t = BlockTime::from(1_765_364_400); // 10 Dec 2025 11:00 UTC
+
+        let json = serde_json::to_string(&t).unwrap();
+        assert_eq!(json, "1765364400"); // ASCII number representation
+
+        let roundtrip = serde_json::from_str::<BlockTime>(&json).unwrap();
+        assert_eq!(t, roundtrip);
+    }
+
+    #[test]
+    #[cfg(all(feature = "encoding", feature = "alloc"))]
+    fn block_time_encoding_round_trip() {
+        let t = BlockTime::from(1_742_979_600); // 26 Mar 2025 9:00 UTC
+        let expected_bytes = alloc::vec![0x10, 0xc2, 0xe3, 0x67];
+
+        let encoded = encoding::encode_to_vec(&t);
+        assert_eq!(encoded, expected_bytes);
+
+        let decoded = encoding::decode_from_slice::<BlockTime>(encoded.as_slice()).unwrap();
+        assert_eq!(decoded, t);
+    }
+
+    #[test]
+    #[cfg(feature = "encoding")]
+    fn block_time_decoding() {
+        let bytes = [0xb0, 0x52, 0x39, 0x69];
+        let expected = BlockTime::from(1_765_364_400); // 10 Dec 2025 11:00 UTC
+
+        let mut decoder = BlockTime::decoder();
+        assert_eq!(decoder.read_limit(), 4);
+        assert!(!decoder.push_bytes(&mut bytes.as_slice()).unwrap());
+        assert_eq!(decoder.read_limit(), 0);
+
+        let decoded = decoder.end().unwrap();
+        assert_eq!(decoded, expected);
+    }
+
+    #[test]
+    #[cfg(all(feature = "encoding", feature = "alloc"))]
+    fn block_time_decoding_error() {
+        let bytes = [0xb0, 0x52, 0x39]; // 3 bytes is an EOF error
+
+        let mut decoder = BlockTimeDecoder::default();
+        assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap());
+
+        let error = decoder.end().unwrap_err();
+        assert!(matches!(error, BlockTimeDecoderError(UnexpectedEofError { .. })));
+    }
 }
diff --git a/units/src/weight.rs b/units/src/weight.rs
index d801dd254c..e701a6695b 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -10,21 +10,22 @@ use arbitrary::{Arbitrary, Unstructured};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use crate::{parse_int, Amount, FeeRate, NumOpResult};
+
 /// The factor that non-witness serialization data is multiplied by during weight calculation.
 pub const WITNESS_SCALE_FACTOR: usize = 4;
 
 mod encapsulate {
-
     /// The weight of a transaction or block.
     ///
-    /// This is an integer newtype representing [`Weight`] in `wu`. It provides protection
-    /// against mixing up types as well as basic formatting features.
+    /// This is an integer newtype representing weight in weight units. It provides protection
+    /// against mixing up the types, conversion functions, and basic formatting.
     #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
     pub struct Weight(u64);
 
     impl Weight {
         /// Constructs a new [`Weight`] from weight units.
-        pub const fn from_wu(wu: u64) -> Self { Weight(wu) }
+        pub const fn from_wu(wu: u64) -> Self { Self(wu) }
 
         /// Returns raw weight units.
         ///
@@ -36,33 +37,33 @@ mod encapsulate {
 pub use encapsulate::Weight;
 
 impl Weight {
-    /// 0 wu.
+    /// Zero weight units (wu).
     ///
     /// Equivalent to [`MIN`](Self::MIN), may better express intent in some contexts.
-    pub const ZERO: Weight = Weight::from_wu(0);
+    pub const ZERO: Self = Self::from_wu(0);
 
     /// Minimum possible value (0 wu).
     ///
     /// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
-    pub const MIN: Weight = Weight::from_wu(u64::MIN);
+    pub const MIN: Self = Self::from_wu(u64::MIN);
 
     /// Maximum possible value.
-    pub const MAX: Weight = Weight::from_wu(u64::MAX);
+    pub const MAX: Self = Self::from_wu(u64::MAX);
 
     /// The factor that non-witness serialization data is multiplied by during weight calculation.
-    pub const WITNESS_SCALE_FACTOR: u64 = WITNESS_SCALE_FACTOR as u64;
+    pub const WITNESS_SCALE_FACTOR: u64 = WITNESS_SCALE_FACTOR as u64; // this value is 4
 
-    /// The maximum allowed weight for a block, see BIP 141 (network rule).
-    pub const MAX_BLOCK: Weight = Weight::from_wu(4_000_000);
+    /// The maximum allowed weight for a block, see BIP-0141 (network rule).
+    pub const MAX_BLOCK: Self = Self::from_wu(4_000_000);
 
     /// The minimum transaction weight for a valid serialized transaction.
-    pub const MIN_TRANSACTION: Weight = Weight::from_wu(Self::WITNESS_SCALE_FACTOR * 60);
+    pub const MIN_TRANSACTION: Self = Self::from_wu(Self::WITNESS_SCALE_FACTOR * 60);
 
     /// Constructs a new [`Weight`] from kilo weight units returning [`None`] if an overflow occurred.
     pub const fn from_kwu(wu: u64) -> Option<Self> {
         // No `map()` in const context.
         match wu.checked_mul(1000) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
@@ -71,7 +72,7 @@ impl Weight {
     pub const fn from_vb(vb: u64) -> Option<Self> {
         // No `map()` in const context.
         match vb.checked_mul(Self::WITNESS_SCALE_FACTOR) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
@@ -81,38 +82,44 @@ impl Weight {
     /// # Panics
     ///
     /// If the conversion from virtual bytes overflows.
-    #[deprecated(since = "TBD", note = "use `from_vb_unchecked` instead")]
-    pub const fn from_vb_unwrap(vb: u64) -> Weight {
+    #[deprecated(since = "1.0.0-rc.0", note = "use `from_vb_unchecked` instead")]
+    pub const fn from_vb_unwrap(vb: u64) -> Self {
         match vb.checked_mul(Self::WITNESS_SCALE_FACTOR) {
-            Some(weight) => Weight::from_wu(weight),
+            Some(weight) => Self::from_wu(weight),
             None => panic!("checked_mul overflowed"),
         }
     }
 
     /// Constructs a new [`Weight`] from virtual bytes without an overflow check.
-    pub const fn from_vb_unchecked(vb: u64) -> Self { Weight::from_wu(vb * 4) }
+    pub const fn from_vb_unchecked(vb: u64) -> Self {
+        Self::from_wu(vb * Self::WITNESS_SCALE_FACTOR)
+    }
 
     /// Constructs a new [`Weight`] from witness size.
-    pub const fn from_witness_data_size(witness_size: u64) -> Self { Weight::from_wu(witness_size) }
+    #[deprecated(since = "1.0.0-rc.1", note = "use `from_wu` instead")]
+    pub const fn from_witness_data_size(witness_size: u64) -> Self { Self::from_wu(witness_size) }
 
     /// Constructs a new [`Weight`] from non-witness size.
+    ///
+    /// # Panics
+    ///
+    /// If the conversion from virtual bytes overflows.
+    #[deprecated(since = "1.0.0-rc.1", note = "use `from_vb` or `from_vb_unchecked` instead")]
     pub const fn from_non_witness_data_size(non_witness_size: u64) -> Self {
-        Weight::from_wu(non_witness_size * Self::WITNESS_SCALE_FACTOR)
+        Self::from_wu(non_witness_size * Self::WITNESS_SCALE_FACTOR)
     }
 
     /// Converts to kilo weight units rounding down.
     pub const fn to_kwu_floor(self) -> u64 { self.to_wu() / 1000 }
 
     /// Converts to kilo weight units rounding up.
-    pub const fn to_kwu_ceil(self) -> u64 { (self.to_wu() + 999) / 1000 }
+    pub const fn to_kwu_ceil(self) -> u64 { self.to_wu().div_ceil(1_000) }
 
     /// Converts to vB rounding down.
     pub const fn to_vbytes_floor(self) -> u64 { self.to_wu() / Self::WITNESS_SCALE_FACTOR }
 
     /// Converts to vB rounding up.
-    pub const fn to_vbytes_ceil(self) -> u64 {
-        (self.to_wu() + Self::WITNESS_SCALE_FACTOR - 1) / Self::WITNESS_SCALE_FACTOR
-    }
+    pub const fn to_vbytes_ceil(self) -> u64 { self.to_wu().div_ceil(Self::WITNESS_SCALE_FACTOR) }
 
     /// Checked addition.
     ///
@@ -121,7 +128,7 @@ impl Weight {
     pub const fn checked_add(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.to_wu().checked_add(rhs.to_wu()) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
@@ -133,7 +140,7 @@ impl Weight {
     pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.to_wu().checked_sub(rhs.to_wu()) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
@@ -145,7 +152,7 @@ impl Weight {
     pub const fn checked_mul(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_wu().checked_mul(rhs) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
@@ -157,10 +164,19 @@ impl Weight {
     pub const fn checked_div(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_wu().checked_div(rhs) {
-            Some(wu) => Some(Weight::from_wu(wu)),
+            Some(wu) => Some(Self::from_wu(wu)),
             None => None,
         }
     }
+
+    /// Checked fee rate multiplication.
+    ///
+    /// Computes the absolute fee amount for a given [`FeeRate`] at this weight. When the resulting
+    /// fee is a non-integer amount, the amount is rounded up, ensuring that the transaction fee is
+    /// enough instead of falling short if rounded down.
+    pub const fn mul_by_fee_rate(self, fee_rate: FeeRate) -> NumOpResult<Amount> {
+        fee_rate.mul_by_weight(self)
+    }
 }
 
 /// Alternative will display the unit.
@@ -230,15 +246,15 @@ crate::internal_macros::impl_add_assign!(Weight);
 crate::internal_macros::impl_sub_assign!(Weight);
 
 impl ops::MulAssign<u64> for Weight {
-    fn mul_assign(&mut self, rhs: u64) { *self = Weight::from_wu(self.to_wu() * rhs); }
+    fn mul_assign(&mut self, rhs: u64) { *self = Self::from_wu(self.to_wu() * rhs); }
 }
 
 impl ops::DivAssign<u64> for Weight {
-    fn div_assign(&mut self, rhs: u64) { *self = Weight::from_wu(self.to_wu() / rhs); }
+    fn div_assign(&mut self, rhs: u64) { *self = Self::from_wu(self.to_wu() / rhs); }
 }
 
 impl ops::RemAssign<u64> for Weight {
-    fn rem_assign(&mut self, rhs: u64) { *self = Weight::from_wu(self.to_wu() % rhs); }
+    fn rem_assign(&mut self, rhs: u64) { *self = Self::from_wu(self.to_wu() % rhs); }
 }
 
 impl core::iter::Sum for Weight {
@@ -246,20 +262,20 @@ impl core::iter::Sum for Weight {
     where
         I: Iterator<Item = Self>,
     {
-        Weight::from_wu(iter.map(Weight::to_wu).sum())
+        Self::from_wu(iter.map(Self::to_wu).sum())
     }
 }
 
-impl<'a> core::iter::Sum<&'a Weight> for Weight {
+impl<'a> core::iter::Sum<&'a Self> for Weight {
     fn sum<I>(iter: I) -> Self
     where
-        I: Iterator<Item = &'a Weight>,
+        I: Iterator<Item = &'a Self>,
     {
         iter.copied().sum()
     }
 }
 
-crate::impl_parse_str_from_int_infallible!(Weight, u64, from_wu);
+parse_int::impl_parse_str_from_int_infallible!(Weight, u64, from_wu);
 
 #[cfg(feature = "serde")]
 impl Serialize for Weight {
@@ -287,7 +303,7 @@ impl<'de> Deserialize<'de> for Weight {
 impl<'a> Arbitrary<'a> for Weight {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let w = u64::arbitrary(u)?;
-        Ok(Weight::from_wu(w))
+        Ok(Self::from_wu(w))
     }
 }
 
@@ -352,6 +368,8 @@ mod tests {
     fn from_vb_unchecked_panic() { Weight::from_vb_unchecked(u64::MAX); }
 
     #[test]
+    #[allow(deprecated)] // tests the deprecated function
+    #[allow(deprecated_in_future)]
     fn from_witness_data_size() {
         let witness_data_size = 1;
         let got = Weight::from_witness_data_size(witness_data_size);
@@ -360,6 +378,8 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)] // tests the deprecated function
+    #[allow(deprecated_in_future)]
     fn from_non_witness_data_size() {
         let non_witness_data_size = 1;
         let got = Weight::from_non_witness_data_size(non_witness_data_size);
@@ -377,6 +397,7 @@ mod tests {
     fn to_kwu_ceil() {
         assert_eq!(Weight::from_wu(1_000).to_kwu_ceil(), 1);
         assert_eq!(Weight::from_wu(1_001).to_kwu_ceil(), 2);
+        assert_eq!(Weight::MAX.to_kwu_ceil(), u64::MAX / 1_000 + 1);
     }
 
     #[test]
@@ -389,6 +410,7 @@ mod tests {
     fn to_vb_ceil() {
         assert_eq!(Weight::from_wu(4).to_vbytes_ceil(), 1);
         assert_eq!(Weight::from_wu(5).to_vbytes_ceil(), 2);
+        assert_eq!(Weight::MAX.to_vbytes_ceil(), u64::MAX / Weight::WITNESS_SCALE_FACTOR + 1);
     }
 
     #[test]
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 33b60bc7bb..db29de38d6 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -12,39 +12,49 @@
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 // These imports test "typical" usage by user code.
-use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
+use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::LockTime`.
 use bitcoin_units::{
-    amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, BlockMtp,
-    BlockMtpInterval, BlockTime, FeeRate, SignedAmount, Weight,
+    amount, block, fee_rate, locktime, parse_int, result, time, weight, Amount, BlockHeight,
+    BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime, FeeRate, NumOpResult, SignedAmount,
+    Weight,
 };
 
 /// A struct that includes all public non-error enums.
 #[derive(Debug)] // All public types implement Debug (C-DEBUG).
 struct Enums {
     a: amount::Denomination,
+    b: NumOpResult<Amount>,
+    c: result::MathOp,
 }
 
 impl Enums {
-    fn new() -> Self { Self { a: amount::Denomination::Bitcoin } }
+    fn new() -> Self {
+        Self {
+            a: amount::Denomination::Bitcoin,
+            b: NumOpResult::Valid(Amount::MAX),
+            c: result::MathOp::Add,
+        }
+    }
 }
 
 /// A struct that includes all public non-error structs.
 #[derive(Debug)] // All public types implement Debug (C-DEBUG).
 struct Structs {
-    a: Amount,
+    // Full path to show alphabetic sort order.
+    a: amount::Amount,
     b: amount::Display,
-    c: SignedAmount,
-    d: BlockHeight,
-    e: BlockInterval,
-    f: FeeRate,
-    g: absolute::Height,
-    h: absolute::MedianTimePast,
-    i: relative::Height,
-    j: relative::Time,
-    k: Weight,
-    l: BlockTime,
-    m: BlockMtp,
-    n: BlockMtpInterval,
+    c: amount::SignedAmount,
+    d: block::BlockHeight,
+    e: block::BlockHeightInterval,
+    f: block::BlockMtp,
+    g: block::BlockMtpInterval,
+    h: fee_rate::FeeRate,
+    i: locktime::absolute::Height,
+    j: locktime::absolute::MedianTimePast,
+    k: locktime::relative::NumberOf512Seconds,
+    l: locktime::relative::NumberOfBlocks,
+    m: time::BlockTime,
+    n: weight::Weight,
 }
 
 impl Structs {
@@ -54,16 +64,16 @@ impl Structs {
             b: Amount::MAX.display_in(amount::Denomination::Bitcoin),
             c: SignedAmount::MAX,
             d: BlockHeight::MAX,
-            e: BlockInterval::MAX,
-            f: FeeRate::MAX,
-            g: absolute::Height::MAX,
-            h: absolute::MedianTimePast::MAX,
-            i: relative::Height::MAX,
-            j: relative::Time::MAX,
-            k: Weight::MAX,
-            l: BlockTime::from_u32(u32::MAX),
-            m: BlockMtp::MAX,
-            n: BlockMtpInterval::MAX,
+            e: BlockHeightInterval::MAX,
+            f: BlockMtp::MAX,
+            g: BlockMtpInterval::MAX,
+            h: FeeRate::MAX,
+            i: absolute::Height::MAX,
+            j: absolute::MedianTimePast::MAX,
+            k: relative::NumberOf512Seconds::MAX,
+            l: relative::NumberOfBlocks::MAX,
+            m: BlockTime::from_u32(u32::MAX),
+            n: Weight::MAX,
         }
     }
 }
@@ -83,19 +93,21 @@ impl Types {
 // C-COMMON-TRAITS excluding `Default` and `Display`. `Display` is done in `./str.rs`.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 struct CommonTraits {
-    a: Amount,
-    c: SignedAmount,
-    d: BlockHeight,
-    e: BlockInterval,
-    f: FeeRate,
-    g: absolute::Height,
-    h: absolute::MedianTimePast,
-    i: relative::Height,
-    j: relative::Time,
-    k: Weight,
-    l: BlockTime,
-    m: BlockMtp,
-    n: BlockMtpInterval,
+    // Full path to show alphabetic sort order.
+    a: amount::Amount,
+    // b: amount::Display,
+    c: amount::SignedAmount,
+    d: block::BlockHeight,
+    e: block::BlockHeightInterval,
+    f: block::BlockMtp,
+    g: block::BlockMtpInterval,
+    h: fee_rate::FeeRate,
+    i: locktime::absolute::Height,
+    j: locktime::absolute::MedianTimePast,
+    k: locktime::relative::NumberOf512Seconds,
+    l: locktime::relative::NumberOfBlocks,
+    m: time::BlockTime,
+    n: weight::Weight,
 }
 
 /// A struct that includes all types that implement `Default`.
@@ -103,84 +115,90 @@ struct CommonTraits {
 struct Default {
     a: Amount,
     b: SignedAmount,
-    c: BlockInterval,
-    d: relative::Height,
-    e: relative::Time,
-    f: BlockMtpInterval,
+    c: BlockHeightInterval,
+    d: BlockMtpInterval,
+    e: relative::NumberOf512Seconds,
+    f: relative::NumberOfBlocks,
 }
 
 /// A struct that includes all public error types.
 // These derives are the policy of `rust-bitcoin` not Rust API guidelines.
 #[derive(Debug, Clone, PartialEq, Eq)] // All public types implement Debug (C-DEBUG).
 struct Errors {
-    a: amount::InputTooLargeError,
-    b: amount::InvalidCharacterError,
-    c: amount::MissingDenominationError,
-    d: amount::MissingDigitsError,
-    e: amount::OutOfRangeError,
-    f: amount::ParseAmountError,
-    g: amount::ParseDenominationError,
-    h: amount::ParseError,
-    i: amount::PossiblyConfusingDenominationError,
-    j: amount::TooPreciseError,
-    k: amount::UnknownDenominationError,
-    l: amount::InputTooLargeError,
-    m: amount::InvalidCharacterError,
-    n: amount::MissingDenominationError,
-    o: amount::MissingDigitsError,
-    p: amount::OutOfRangeError,
-    q: amount::ParseAmountError,
-    r: amount::ParseDenominationError,
-    s: amount::ParseError,
-    t: amount::PossiblyConfusingDenominationError,
-    u: amount::TooPreciseError,
-    v: amount::UnknownDenominationError,
-    w: block::TooBigForRelativeHeightError,
-    x: locktime::absolute::ConversionError,
-    y: locktime::absolute::Height,
-    z: locktime::absolute::ParseHeightError,
-    _a: locktime::absolute::ParseTimeError,
-    _b: locktime::relative::TimeOverflowError,
-    _e: parse::ParseIntError,
-    _f: parse::PrefixedHexError,
-    _g: parse::UnprefixedHexError,
+    a: amount::error::InputTooLargeError,
+    b: amount::error::InvalidCharacterError,
+    c: amount::error::MissingDenominationError,
+    d: amount::error::MissingDigitsError,
+    e: amount::error::OutOfRangeError,
+    f: amount::error::ParseAmountError,
+    g: amount::error::ParseDenominationError,
+    h: amount::error::ParseError,
+    i: amount::error::PossiblyConfusingDenominationError,
+    j: amount::error::TooPreciseError,
+    k: amount::error::UnknownDenominationError,
+    l: block::TooBigForRelativeHeightError,
+    #[cfg(feature = "serde")]
+    m: fee_rate::serde::OverflowError,
+    n: locktime::absolute::ConversionError,
+    o: locktime::absolute::ParseHeightError,
+    p: locktime::absolute::ParseTimeError,
+    q: locktime::relative::InvalidHeightError,
+    r: locktime::relative::InvalidTimeError,
+    s: locktime::relative::TimeOverflowError,
+    t: parse_int::ParseIntError,
+    u: parse_int::PrefixedHexError,
+    v: parse_int::UnprefixedHexError,
 }
 
 #[test]
 fn api_can_use_modules_from_crate_root() {
-    use bitcoin_units::{amount, block, fee_rate, locktime, parse, time, weight};
+    use bitcoin_units::{amount, block, fee_rate, locktime, parse_int, time, weight};
 }
 
 #[test]
 fn api_can_use_types_from_crate_root() {
     use bitcoin_units::{
-        Amount, BlockHeight, BlockInterval, BlockMtp, BlockMtpInterval, BlockTime, FeeRate,
-        SignedAmount, Weight,
+        Amount, BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime, FeeRate,
+        NumOpResult, SignedAmount, Weight,
     };
 }
 
 #[test]
 fn api_can_use_all_types_from_module_amount() {
     use bitcoin_units::amount::{
-        Amount, Denomination, Display, InputTooLargeError, InvalidCharacterError,
-        MissingDenominationError, MissingDigitsError, OutOfRangeError, ParseAmountError,
-        ParseDenominationError, ParseError, PossiblyConfusingDenominationError, SignedAmount,
-        TooPreciseError, UnknownDenominationError,
+        Amount, Denomination, Display, OutOfRangeError, ParseAmountError, ParseDenominationError,
+        ParseError, SignedAmount,
+    };
+}
+
+#[test]
+fn api_can_use_all_types_from_module_amount_error() {
+    use bitcoin_units::amount::error::{
+        InputTooLargeError, InvalidCharacterError, MissingDenominationError, MissingDigitsError,
+        OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
+        PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
     };
 }
 
 #[test]
 fn api_can_use_all_types_from_module_block() {
-    use bitcoin_units::block::{BlockHeight, BlockHeightInterval, TooBigForRelativeHeightError};
+    use bitcoin_units::block::{
+        BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, TooBigForRelativeHeightError,
+    };
 }
 
 #[test]
 fn api_can_use_all_types_from_module_fee_rate() {
+    #[cfg(feature = "serde")]
+    use bitcoin_units::fee_rate::serde::OverflowError;
     use bitcoin_units::fee_rate::FeeRate;
 }
 
 #[test]
 fn api_can_use_all_types_from_module_locktime_absolute() {
+    use bitcoin_units::locktime::absolute::error::{
+        ConversionError as _, ParseHeightError as _, ParseTimeError as _,
+    };
     use bitcoin_units::locktime::absolute::{
         ConversionError, Height, MedianTimePast, ParseHeightError, ParseTimeError,
     };
@@ -188,12 +206,17 @@ fn api_can_use_all_types_from_module_locktime_absolute() {
 
 #[test]
 fn api_can_use_all_types_from_module_locktime_relative() {
-    use bitcoin_units::locktime::relative::{Height, Time, TimeOverflowError};
+    use bitcoin_units::locktime::relative::error::{
+        InvalidHeightError as _, InvalidTimeError as _, TimeOverflowError as _,
+    };
+    use bitcoin_units::locktime::relative::{
+        InvalidHeightError, InvalidTimeError, NumberOf512Seconds, NumberOfBlocks, TimeOverflowError,
+    };
 }
 
 #[test]
 fn api_can_use_all_types_from_module_parse() {
-    use bitcoin_units::parse::{ParseIntError, PrefixedHexError, UnprefixedHexError};
+    use bitcoin_units::parse_int::{ParseIntError, PrefixedHexError, UnprefixedHexError};
 }
 
 #[test]
@@ -260,10 +283,10 @@ fn regression_default() {
     let want = Default {
         a: Amount::ZERO,
         b: SignedAmount::ZERO,
-        c: BlockInterval::ZERO,
-        d: relative::Height::ZERO,
-        e: relative::Time::ZERO,
-        f: BlockMtpInterval::ZERO,
+        c: BlockHeightInterval::ZERO,
+        d: BlockMtpInterval::ZERO,
+        e: relative::NumberOf512Seconds::ZERO,
+        f: relative::NumberOfBlocks::ZERO,
     };
     assert_eq!(got, want);
 }
@@ -272,18 +295,17 @@ fn regression_default() {
 fn dyn_compatible() {
     // If this builds then traits are dyn compatible.
     struct Traits {
-        a: Box<dyn amount::CheckedSum<Amount>>,
         // These traits are explicitly not dyn compatible.
         // b: Box<dyn amount::serde::SerdeAmount>,
         // c: Box<dyn amount::serde::SerdeAmountForOpt>,
-        // d: Box<dyn parse::Integer>,
+        // d: Box<dyn parse::Integer>, // Because of core::num::ParseIntError
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Types {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let a = Types { a: Enums::arbitrary(u)?, b: Structs::arbitrary(u)? };
+        let a = Self { a: Enums::arbitrary(u)?, b: Structs::arbitrary(u)? };
         Ok(a)
     }
 }
@@ -291,22 +313,22 @@ impl<'a> Arbitrary<'a> for Types {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Structs {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let a = Structs {
+        let a = Self {
             a: Amount::arbitrary(u)?,
             // Skip the `Display` type.
             b: Amount::MAX.display_in(amount::Denomination::Bitcoin),
             c: SignedAmount::arbitrary(u)?,
             d: BlockHeight::arbitrary(u)?,
-            e: BlockInterval::arbitrary(u)?,
-            f: FeeRate::arbitrary(u)?,
-            g: absolute::Height::arbitrary(u)?,
-            h: absolute::MedianTimePast::arbitrary(u)?,
-            i: relative::Height::arbitrary(u)?,
-            j: relative::Time::arbitrary(u)?,
-            k: Weight::arbitrary(u)?,
-            l: BlockTime::arbitrary(u)?,
-            m: BlockMtp::arbitrary(u)?,
-            n: BlockMtpInterval::arbitrary(u)?,
+            e: BlockHeightInterval::arbitrary(u)?,
+            f: BlockMtp::arbitrary(u)?,
+            g: BlockMtpInterval::arbitrary(u)?,
+            h: FeeRate::arbitrary(u)?,
+            i: absolute::Height::arbitrary(u)?,
+            j: absolute::MedianTimePast::arbitrary(u)?,
+            k: relative::NumberOf512Seconds::arbitrary(u)?,
+            l: relative::NumberOfBlocks::arbitrary(u)?,
+            m: BlockTime::arbitrary(u)?,
+            n: Weight::arbitrary(u)?,
         };
         Ok(a)
     }
@@ -315,7 +337,11 @@ impl<'a> Arbitrary<'a> for Structs {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Enums {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let a = Enums { a: amount::Denomination::arbitrary(u)? };
+        let a = Self {
+            a: amount::Denomination::arbitrary(u)?,
+            b: NumOpResult::<Amount>::arbitrary(u)?,
+            c: result::MathOp::arbitrary(u)?,
+        };
         Ok(a)
     }
 }
diff --git a/units/tests/data/serde_bincode b/units/tests/data/serde_bincode
index 51d7dc1d09..9131b615a2 100644
Binary files a/units/tests/data/serde_bincode and b/units/tests/data/serde_bincode differ
diff --git a/units/tests/serde.rs b/units/tests/serde.rs
index 4c93da1f0d..dafd594ae9 100644
--- a/units/tests/serde.rs
+++ b/units/tests/serde.rs
@@ -6,11 +6,10 @@
 #![cfg(feature = "serde")]
 
 use bincode::serialize;
-use bitcoin_units::locktime::{absolute, relative};
-use bitcoin_units::{
-    amount, fee_rate, Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight,
-};
+use bitcoin_units::{amount, fee_rate, Amount, BlockHeight, BlockHeightInterval, BlockTime, FeeRate, Sequence, SignedAmount, Weight};
 use serde::{Deserialize, Serialize};
+use bitcoin_units::absolute::{LockTime as AbsoluteLockTime, Height, MedianTimePast};
+use bitcoin_units::relative::{LockTime as RelativeLockTime, NumberOf512Seconds, NumberOfBlocks};
 
 /// A struct that includes all the types that implement or support `serde` traits.
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,22 +36,24 @@ struct Serde {
     vb_floor: FeeRate,
     #[serde(with = "fee_rate::serde::as_sat_per_vb_ceil")]
     vb_ceil: FeeRate,
-    #[serde(with = "fee_rate::serde::as_sat_per_kwu")]
+    #[serde(with = "fee_rate::serde::as_sat_per_kwu_floor")]
     kwu: FeeRate,
     #[serde(with = "fee_rate::serde::as_sat_per_vb_floor::opt")]
     opt_vb_floor: Option<FeeRate>,
     #[serde(with = "fee_rate::serde::as_sat_per_vb_ceil::opt")]
     opt_vb_ceil: Option<FeeRate>,
-    #[serde(with = "fee_rate::serde::as_sat_per_kwu::opt")]
+    #[serde(with = "fee_rate::serde::as_sat_per_kwu_floor::opt")]
     opt_kwu: Option<FeeRate>,
 
-    a: BlockHeight,
-    b: BlockInterval,
-    c: absolute::Height,
-    d: absolute::MedianTimePast,
-    e: relative::Height,
-    f: relative::Time,
-    g: Weight,
+    block_height: BlockHeight,
+    block_height_interval: BlockHeightInterval,
+    weight: Weight,
+
+    block_time: BlockTime,
+    seq: Sequence,
+
+    abs_locktime: AbsoluteLockTime,
+    rel_locktime: RelativeLockTime,
 }
 
 impl Serde {
@@ -79,13 +80,14 @@ impl Serde {
             opt_vb_ceil: Some(FeeRate::BROADCAST_MIN),
             opt_kwu: Some(FeeRate::BROADCAST_MIN),
 
-            a: BlockHeight::MAX,
-            b: BlockInterval::MAX,
-            c: absolute::Height::MAX,
-            d: absolute::MedianTimePast::MAX,
-            e: relative::Height::MAX,
-            f: relative::Time::MAX,
-            g: Weight::MAX,
+            block_height: BlockHeight::MAX,
+            block_height_interval: BlockHeightInterval::MAX,
+            weight: Weight::MAX,
+
+            block_time: BlockTime::from_u32(1_742_979_600),
+            seq: Sequence::MAX,
+            abs_locktime: AbsoluteLockTime::Blocks(Height::MAX),
+            rel_locktime: RelativeLockTime::Blocks(NumberOfBlocks::MAX),
         }
     }
 }
@@ -97,3 +99,566 @@ fn serde_regression() {
     let want = include_bytes!("data/serde_bincode");
     assert_eq!(got, want);
 }
+
+#[track_caller]
+fn sat(sat: u64) -> Amount { Amount::from_sat(sat).unwrap() }
+
+#[track_caller]
+fn ssat(ssat: i64) -> SignedAmount { SignedAmount::from_sat(ssat).unwrap() }
+
+#[test]
+#[cfg(feature = "serde")]
+fn serde_amount_as_sat() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_sat")]
+        pub amt: Amount,
+        #[serde(with = "crate::amount::serde::as_sat")]
+        pub samt: SignedAmount,
+    }
+
+    serde_test::assert_tokens(
+        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 2 },
+            serde_test::Token::Str("amt"),
+            serde_test::Token::I64(123_456_789),
+            serde_test::Token::Str("samt"),
+            serde_test::Token::I64(-123_456_789),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+fn serde_amount_as_btc() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_btc")]
+        pub amt: Amount,
+        #[serde(with = "crate::amount::serde::as_btc")]
+        pub samt: SignedAmount,
+    }
+
+    let orig = T { amt: sat(20_000_000__000_000_01), samt: ssat(-20_000_000__000_000_01) };
+
+    let json = "{\"amt\": 20000000.00000001, \
+                \"samt\": -20000000.00000001}";
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_amount_as_str() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_str")]
+        pub amt: Amount,
+        #[serde(with = "crate::amount::serde::as_str")]
+        pub samt: SignedAmount,
+    }
+
+    serde_test::assert_tokens(
+        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 2 },
+            serde_test::Token::String("amt"),
+            serde_test::Token::String("1.23456789"),
+            serde_test::Token::String("samt"),
+            serde_test::Token::String("-1.23456789"),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+fn serde_amount_as_btc_opt() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+    struct T {
+        #[serde(default, with = "crate::amount::serde::as_btc::opt")]
+        pub amt: Option<Amount>,
+        #[serde(default, with = "crate::amount::serde::as_btc::opt")]
+        pub samt: Option<SignedAmount>,
+    }
+
+    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
+    let without = T { amt: None, samt: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T = serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value =
+        serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+fn serde_amount_as_sat_opt() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+    struct T {
+        #[serde(default, with = "crate::amount::serde::as_sat::opt")]
+        pub amt: Option<Amount>,
+        #[serde(default, with = "crate::amount::serde::as_sat::opt")]
+        pub samt: Option<SignedAmount>,
+    }
+
+    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
+    let without = T { amt: None, samt: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T = serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value =
+        serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+fn serde_amount_as_str_opt() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+    struct T {
+        #[serde(default, with = "crate::amount::serde::as_str::opt")]
+        pub amt: Option<Amount>,
+        #[serde(default, with = "crate::amount::serde::as_str::opt")]
+        pub samt: Option<SignedAmount>,
+    }
+
+    let with = T { amt: Some(sat(123_456_789)), samt: Some(ssat(-123_456_789)) };
+    let without = T { amt: None, samt: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T =
+        serde_json::from_str("{\"amt\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value =
+        serde_json::from_str("{\"amt\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[track_caller]
+fn fee_rate_vb(vb: u32) -> FeeRate {
+    FeeRate::from_sat_per_vb(vb)
+}
+
+#[track_caller]
+fn fee_rate_kwu(vb: u32) -> FeeRate {
+    FeeRate::from_sat_per_kwu(vb)
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_vb_floor() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "fee_rate::serde::as_sat_per_vb_floor")]
+        pub fee_rate: FeeRate,
+    }
+
+    serde_test::assert_tokens(
+        &T { fee_rate: fee_rate_vb(123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 1 },
+            serde_test::Token::Str("fee_rate"),
+            serde_test::Token::U64(123_456_789),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_kwu_floor() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::fee_rate::serde::as_sat_per_kwu_floor")]
+        pub fee_rate: FeeRate,
+    }
+
+    serde_test::assert_tokens(
+        &T { fee_rate: fee_rate_kwu(123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 1 },
+            serde_test::Token::Str("fee_rate"),
+            serde_test::Token::U64(123_456_789),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_vb_ceil() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "fee_rate::serde::as_sat_per_vb_ceil")]
+        pub fee_rate: FeeRate,
+    }
+
+    serde_test::assert_tokens(
+        &T { fee_rate: fee_rate_vb(123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 1 },
+            serde_test::Token::Str("fee_rate"),
+            serde_test::Token::U64(123_456_789),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_floor_vs_ceil() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, Debug, PartialEq)]
+    struct Floor {
+        #[serde(with = "fee_rate::serde::as_sat_per_vb_floor")]
+        fee_rate: FeeRate,
+    }
+
+    #[derive(Serialize, Deserialize, Debug, PartialEq)]
+    struct Ceil {
+        #[serde(with = "fee_rate::serde::as_sat_per_vb_ceil")]
+        fee_rate: FeeRate,
+    }
+
+    let fee_rate = FeeRate::from_sat_per_kwu(251);
+
+    let floor = Floor { fee_rate };
+    let ceil = Ceil { fee_rate };
+
+    let floor_json = serde_json::to_string(&floor).unwrap();
+    let ceil_json = serde_json::to_string(&ceil).unwrap();
+
+    assert!(floor_json.contains("\"fee_rate\":1"));
+    assert!(ceil_json.contains("\"fee_rate\":2"));
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_kwu_floor_opt() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(default, with = "crate::fee_rate::serde::as_sat_per_kwu_floor::opt")]
+        pub fee_rate: Option<FeeRate>,
+    }
+
+    let with = T { fee_rate: Some(fee_rate_kwu(123_456_789)) };
+    let without = T { fee_rate: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_vb_floor_opt() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(default, with = "crate::fee_rate::serde::as_sat_per_vb_floor::opt")]
+        pub fee_rate: Option<FeeRate>,
+    }
+
+    let with = T { fee_rate: Some(fee_rate_vb(123_456_789)) };
+    let without = T { fee_rate: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_fee_rate_as_sat_per_vb_ceil_opt() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(default, with = "crate::fee_rate::serde::as_sat_per_vb_ceil::opt")]
+        pub fee_rate: Option<FeeRate>,
+    }
+
+    let with = T { fee_rate: Some(fee_rate_vb(123_456_789)) };
+    let without = T { fee_rate: None };
+
+    // Test Roundtripping
+    for s in [&with, &without] {
+        let v = serde_json::to_string(s).unwrap();
+        let w: T = serde_json::from_str(&v).unwrap();
+        assert_eq!(w, *s);
+    }
+
+    let t: T = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value = serde_json::from_str("{\"fee_rate\": 123456789}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_block_height() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub block_height: BlockHeight
+    }
+
+    let orig = T {
+        block_height: BlockHeight::from_u32(123_456_789)
+    };
+
+    let json = "{\"block_height\": 123456789}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_block_interval() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub block_interval: BlockHeightInterval
+    }
+
+    let orig = T {
+        block_interval: BlockHeightInterval::from_u32(144)
+    };
+
+    let json = "{\"block_interval\": 144}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_weight() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub weight: Weight
+    }
+
+    let orig = T {
+        weight: Weight::from_wu(25)
+    };
+
+    let json = "{\"weight\": 25}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_block_time() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub block_time: BlockTime
+    }
+
+    let orig = T {
+        block_time: BlockTime::from_u32(123_456_789)
+    };
+
+    let json = "{\"block_time\": 123456789}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_sequence_from_hex() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub sequence: Sequence
+    }
+
+    let orig = T {
+        sequence: Sequence::from_hex("0x0040ffff").unwrap()
+    };
+
+    let json = "{\"sequence\": 4259839}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_locktime_from_blocks() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub a_lt: AbsoluteLockTime,
+        pub r_lt: RelativeLockTime,
+    }
+
+    let orig = T {
+        a_lt: AbsoluteLockTime::Blocks(Height::from_u32(1_000).unwrap()),
+        r_lt: RelativeLockTime::Blocks(NumberOfBlocks::from_height(1_000)),
+    };
+
+    let json = "{\"a_lt\": 1000, \"r_lt\": 1000}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
+
+#[test]
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+fn serde_as_locktime_from_time() {
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        pub a_lt: AbsoluteLockTime,
+        pub r_lt: RelativeLockTime,
+    }
+
+    let orig = T {
+        a_lt: AbsoluteLockTime::Seconds(MedianTimePast::from_u32(1_653_195_600).unwrap()),
+        r_lt: RelativeLockTime::Time(NumberOf512Seconds::from_512_second_intervals(70)),
+    };
+
+    let json = "{\"a_lt\": 1653195600, \"r_lt\": 4194374}";
+
+    let t: T = serde_json::from_str(json).unwrap();
+    assert_eq!(t, orig);
+
+    let value: serde_json::Value = serde_json::from_str(json).unwrap();
+    assert_eq!(t, serde_json::from_value(value).unwrap());
+}
diff --git a/units/tests/str.rs b/units/tests/str.rs
index 8bc7146837..b0774d0ca4 100644
--- a/units/tests/str.rs
+++ b/units/tests/str.rs
@@ -4,7 +4,7 @@
 
 use bitcoin_units::amount::Denomination;
 use bitcoin_units::locktime::{absolute, relative};
-use bitcoin_units::{Amount, BlockHeight, BlockInterval, SignedAmount, Weight};
+use bitcoin_units::{Amount, BlockHeight, BlockHeightInterval, SignedAmount, Weight};
 
 macro_rules! check {
     ($($test_name:ident, $ty:path, $val:path, $str:literal);* $(;)?) => {
@@ -34,20 +34,20 @@ check! {
     block_height_min, BlockHeight, BlockHeight::MIN, "0";
     block_height_max, BlockHeight, BlockHeight::MAX, "4294967295";
 
-    block_interval_min, BlockInterval, BlockInterval::MIN, "0";
-    block_interval_max, BlockInterval, BlockInterval::MAX, "4294967295";
+    block_interval_min, BlockHeightInterval, BlockHeightInterval::MIN, "0";
+    block_interval_max, BlockHeightInterval, BlockHeightInterval::MAX, "4294967295";
 
     lock_by_height_absolute_min, absolute::Height, absolute::Height::MIN, "0";
     lock_by_height_absolute_max, absolute::Height, absolute::Height::MAX, "499999999";
 
-    lock_by_height_relative_min, relative::Height, relative::Height::MIN, "0";
-    lock_by_height_relative_max, relative::Height, relative::Height::MAX, "65535";
+    lock_by_height_relative_min, relative::NumberOfBlocks, relative::NumberOfBlocks::MIN, "0";
+    lock_by_height_relative_max, relative::NumberOfBlocks, relative::NumberOfBlocks::MAX, "65535";
 
-    lock_by_time_absolute_min, absolute::Time, absolute::Time::MIN, "500000000";
-    lock_by_time_absolute_max, absolute::Time, absolute::Time::MAX, "4294967295";
+    lock_by_time_absolute_min, absolute::MedianTimePast, absolute::MedianTimePast::MIN, "500000000";
+    lock_by_time_absolute_max, absolute::MedianTimePast, absolute::MedianTimePast::MAX, "4294967295";
 
-    lock_by_time_relative_min, relative::Time, relative::Time::MIN, "0";
-    lock_by_time_relative_max, relative::Time, relative::Time::MAX, "65535";
+    lock_by_time_relative_min, relative::NumberOf512Seconds, relative::NumberOf512Seconds::MIN, "0";
+    lock_by_time_relative_max, relative::NumberOf512Seconds, relative::NumberOf512Seconds::MAX, "65535";
 
     weight_min, Weight, Weight::MIN, "0";
     weight_max, Weight, Weight::MAX, "18446744073709551615";