diff --git a/.github/workflows/ci-failure-issues.yml b/.github/workflows/ci-failure-issues.yml
new file mode 100644
index 00000000..d3c8312c
--- /dev/null
+++ b/.github/workflows/ci-failure-issues.yml
@@ -0,0 +1,92 @@
+name: CI Failure Issues
+
+on:
+  workflow_run:  # zizmor: ignore[dangerous-triggers]
+    workflows:
+      - Fuzz
+    types:
+      - completed
+    branches:
+      - master
+
+permissions:
+  issues: write
+
+concurrency:
+  group: ci-failure-issues-${{ github.event.workflow_run.name }}
+  cancel-in-progress: false
+
+jobs:
+  sync-issue:
+    if: ${{ contains(fromJson('["failure","success"]'), github.event.workflow_run.conclusion) }}
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        with:
+          script: |
+            const run = context.payload.workflow_run;
+            const workflow = run.name;
+            const marker = `<!-- ci-failure-key:${workflow} -->`;
+            const workflowFiles = {
+              "Fuzz": "cron-daily-fuzz.yml",
+            };
+
+            const formatTs = iso => {
+              const d = new Date(iso);
+              const pad = n => String(n).padStart(2, "0");
+              return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} at ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())} UTC`;
+            };
+            const shortSha = sha => (sha || "unknown").slice(0, 7);
+            const commitUrl = sha => `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/commit/${sha}`;
+            const workflowUrl = workflowFiles[workflow]
+              ? `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/workflows/${workflowFiles[workflow]}`
+              : `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions?query=${encodeURIComponent(`workflow:"${workflow}"`)}`;
+
+            function titleFor() {
+              return `The ${workflow} workflow is failing`;
+            }
+
+            function bodyForFailure() {
+              return [
+                marker,
+                "",
+                `The [${workflow} workflow](${workflowUrl}) started failing on ${formatTs(run.created_at)}: [${workflow} #${run.run_number}](${run.html_url}) - [\`${shortSha(run.head_sha)}\`](${commitUrl(run.head_sha)})`,
+              ].join("\n");
+            }
+
+            const issues = await github.paginate(github.rest.issues.listForRepo, {
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: "open",
+              per_page: 100,
+            });
+
+            const existing = issues.find(issue =>
+              !issue.pull_request && issue.body && issue.body.includes(marker)
+            );
+
+            if (run.conclusion === "failure" && !existing) {
+              await github.rest.issues.create({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                title: titleFor(),
+                body: bodyForFailure(),
+              });
+            }
+
+            if (run.conclusion === "success" && existing) {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: existing.number,
+                body: `The [${workflow} workflow](${workflowUrl}) successfully ran again on ${formatTs(run.created_at)}: [${workflow} #${run.run_number}](${run.html_url}).`,
+              });
+
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: existing.number,
+                state: "closed",
+              });
+            }
diff --git a/.github/workflows/cron-daily-fuzz.yml b/.github/workflows/cron-daily-fuzz.yml
new file mode 100644
index 00000000..7f3af38e
--- /dev/null
+++ b/.github/workflows/cron-daily-fuzz.yml
@@ -0,0 +1,72 @@
+######
+## DO NOT EDIT THIS FILE DIRECTLY. It is generated by generate-files.sh.
+## Edit that script instead and re-run it.
+######
+name: Fuzz
+on:
+  schedule:
+    # 5am every day UTC, this correlates to:
+    # - 10pm PDT
+    # - 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:
+        fuzz_target: [
+          deserialize_block,
+          deserialize_output,
+          deserialize_pset,
+          deserialize_transaction,
+        ]
+    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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        id: cache-fuzz
+        with:
+          path: |
+            ~/.cargo/bin
+            fuzz/target
+            target
+          key: cache-${{ matrix.target }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
+        with:
+          toolchain: '1.74.0'
+      - name: fuzz
+        run: |
+          echo "Using RUSTFLAGS $RUSTFLAGS"
+          cd fuzz && ./fuzz.sh "${{ matrix.fuzz_target }}"
+      - run: echo "${{ matrix.fuzz_target }}" >executed_${{ matrix.fuzz_target }}
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: executed_${{ matrix.fuzz_target }}
+          path: executed_${{ matrix.fuzz_target }}
+
+  verify-execution:
+    if: ${{ !github.event.act }}
+    needs: fuzz
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+      - run: cargo install --locked --version 0.12.0 cargo-fuzz
+      - name: Display structure of downloaded files
+        run: ls -R
+      - run: find executed_* -type f -exec cat {} + | sort > executed
+      - run: cargo fuzz list | sort | diff - executed
diff --git a/.github/workflows/cron-weekly-update-nightly.yml b/.github/workflows/cron-weekly-update-nightly.yml
new file mode 100644
index 00000000..c85c80b1
--- /dev/null
+++ b/.github/workflows/cron-weekly-update-nightly.yml
@@ -0,0 +1,35 @@
+name: Update Nightly rustc
+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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: Install cargo-rbmt
+        run: cargo install --git https://github.com/rust-bitcoin/rust-bitcoin-maintainer-tools.git --rev $(cat rbmt-version) cargo-rbmt
+      - name: Update nightly toolchain in Cargo.toml
+        run: |
+          eval "$(cargo rbmt toolchains --update-nightly)"
+          echo "nightly_version=$RBMT_NIGHTLY" >> $GITHUB_ENV
+      - name: Create Pull Request
+        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>
+          committer: Update Nightly Rustc Bot <bot@example.com>
+          title: Automated daily update to rustc (to ${{ env.nightly_version }})
+          body: |
+           Automated update to Cargo.toml workspace metadata by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action
+          commit-message: Automated update to rustc ${{ env.nightly_version }}
+          branch: create-pull-request/daily-nightly-update
diff --git a/.github/workflows/cron-weekly-update-stable.yml b/.github/workflows/cron-weekly-update-stable.yml
new file mode 100644
index 00000000..3ffd4e1d
--- /dev/null
+++ b/.github/workflows/cron-weekly-update-stable.yml
@@ -0,0 +1,34 @@
+name: Update Stable rustc
+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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - name: Install cargo-rbmt
+        run: cargo install --git https://github.com/rust-bitcoin/rust-bitcoin-maintainer-tools.git --rev $(cat rbmt-version) cargo-rbmt
+      - name: Update stable toolchain in Cargo.toml
+        run: |
+          eval "$(cargo rbmt toolchains --update-stable)"
+          echo "stable_version=$RBMT_STABLE" >> $GITHUB_ENV
+      - name: Create Pull Request
+        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>
+          committer: Update Stable Rustc Bot <bot@example.com>
+          title: Automated weekly update to rustc stable (to ${{ env.stable_version }})
+          body: |
+           Automated update to Cargo.toml workspace metadata by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action
+          commit-message: Automated update to rustc stable-${{ env.stable_version }}
+          branch: create-pull-request/weekly-stable-update
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index f8c56286..4dc44501 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -1,41 +1,130 @@
 on: [push, pull_request]
 
-name: Continuous integration
+name: Continuous Integration
+
+permissions:
+  contents: read
 
 jobs:
-  Tests:
-    name: Tests
-    runs-on: ubuntu-latest
+  Test: # 6 jobs: 3 toolchains × 2 lock files.
+    name: Test - ${{ matrix.toolchain }} toolchain (${{ matrix.dep }})
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - rust: 1.58.0
-            env:
-              DO_FUZZ: true
-          - rust: stable
-            env:
-              DO_INTEGRATION: true
-          - rust: beta
-            env:
-              DUMMY: true
-          - rust: nightly
-            env:
-              DUMMY: true
-          - rust: 1.41.1
-            env:
-              PIN_VERSIONS: true
-    steps:
-      - name: Install test dependencies
-        run: sudo apt-get install -y binutils-dev libunwind8-dev
+        dep: [recent]
+        toolchain: [stable, nightly, msrv]
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: Run ${{ matrix.toolchain }} tests
+        run: |
+          export ELEMENTSD_EXE="$PWD/elementsd-tests/bin/elementsd"
+          if [ "${{ matrix.toolchain }}" = "msrv" ]; then
+            MSRV="$(cargo rbmt toolchains --msrv)"
+            cp "Cargo-${{ matrix.dep }}.lock" Cargo.lock
+            cargo +"$MSRV" test --locked
+          else
+            cargo rbmt --lock-file ${{ matrix.dep }} test --toolchain ${{ matrix.toolchain }}
+          fi
+
+  Lint:
+    name: Lint - nightly toolchain
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: Run lints
+        run: cargo rbmt --lock-file recent lint
+
+  Docs:
+    name: Docs - stable toolchain
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: Run doc tests
+        run: cargo rbmt --lock-file recent docs
+
+  Docsrs:
+    name: Docs - nightly toolchain
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: Run docsrs tests
+        run: cargo rbmt --lock-file recent docsrs
+
+#  Format: # 1 job, run cargo fmt directly.
+#    name: Format - nightly toolchain
+#    runs-on: ubuntu-24.04
+#    steps:
+#      - name: Checkout Crate
+#        uses: actions/checkout@v4
+#      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+#      - name: Check formatting
+#        run: cargo rbmt --lock-file recent fmt --check
+
+  Bench:
+    name: Bench - nightly toolchain
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - uses: rust-bitcoin/rust-bitcoin-maintainer-tools/.github/actions/setup-rbmt@af3c2868415b17eedc808da6d0589e10b7482660 # v0.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: Run benches
+        run: cargo rbmt --lock-file recent bench
+
+  Arch32bit:
+    name: Test 32-bit version
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Add architecture i386
+        run: sudo dpkg --add-architecture i386
+      - name: Install i686 gcc
+        run: sudo apt-get update -y && sudo apt-get install -y gcc-multilib
+      - name: Install target
+        run: rustup target add i686-unknown-linux-gnu
+      - name: Run tests on i686
+        run: cargo test --target i686-unknown-linux-gnu
+
+  Cross:
+    name: Cross test
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Install target
+        run: rustup target add s390x-unknown-linux-gnu
+      - name: install cross
+        run: cargo install cross --locked
+      - name: run cross test
+        run: cross test --target s390x-unknown-linux-gnu
+
+  Wasm:
+    name: Check WASM
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
       - name: Checkout Crate
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Checkout Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-      - name: Running test script
-        env: ${{ matrix.env }}
-        run: ./contrib/test.sh
+        uses: dtolnay/rust-toolchain@stable
+      - run: rustup target add wasm32-unknown-unknown
+      - run: cargo check --target wasm32-unknown-unknown
diff --git a/.gitignore b/.gitignore
index 2e47091b..42dea11a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ Cargo.lock
 *~
 
 #fuzz
-fuzz/hfuzz_target
-fuzz/hfuzz_workspace
+fuzz/corpus
+fuzz/artifacts
+fuzz/*.log
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 365e75c4..ff4f1a45 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,117 @@
+# 0.27.0 - 2026-07-28
+
+This release updates several dependencies. It attempts to minimize API breakage beyond updating
+the dependencies. It should be considered a "transitional release" as we modernize the crate's API
+over the next several releases. In particular, this release introduces a new encoding paradigm but
+does not remove the old one, so depending on this may help users transition.
+
+Dependency updates:
+
+* **Bump MRSV to 1.74.0**
+  [#269](https://github.com/ElementsProject/rust-elements/pull/269)
+  [#265](https://github.com/ElementsProject/rust-elements/pull/265)
+* Update `bitcoin_hashes` dependency to newly-stable 1.0; improve array/slice APIs
+* Replace custom hex parsing with newly-stable `hex-conservative` 1.0
+  [#261](https://github.com/ElementsProject/rust-elements/pull/261)
+  [#272](https://github.com/ElementsProject/rust-elements/pull/272)
+* Introduce newly-stable `bitcoin-consensus-encoding` 1.0 crate and implement its `Encode` and
+  `Decode` traits on `Transaction` and subtypes.
+  [#288](https://github.com/ElementsProject/rust-elements/pull/288)
+
+
+* Remove `TxOut::MAX_MONEY` whose use is likely incorrect on a multi-asset chain
+  [#261](https://github.com/ElementsProject/rust-elements/pull/261)
+* pset: fix pegin/issuance flag handling in extract_tx
+  [#278](https://github.com/ElementsProject/rust-elements/pull/278)
+  [#279](https://github.com/ElementsProject/rust-elements/pull/279)
+  [#282](https://github.com/ElementsProject/rust-elements/pull/282)
+* Implement calculation of AssetId and genesis blocks
+  [#276](https://github.com/ElementsProject/rust-elements/pull/276)
+* Improve type safety for objects related to confidential transactions and asset issuance
+  [#286](https://github.com/ElementsProject/rust-elements/pull/286)
+  [#289](https://github.com/ElementsProject/rust-elements/pull/289)
+
+# 0.26.2 - 2026-06-15
+
+* Fix multiple panics related to slicing and blinding data validation
+
+# 0.26.1 - 2025-08-28
+
+* [#250](https://github.com/ElementsProject/rust-elements/pull/250) API cleanups
+  * implement `Encodable` and `Decodable` for `Vec<T>` whenever `T` is `Encodable`/`Decodable` and `'static`
+  * add missing export of error sub-type `pset::PsetHash`
+
+# 0.26.0 - 2025-08-22
+
+* [#249](https://github.com/ElementsProject/rust-elements/pull/249) docs: fix changelog links
+* [#243](https://github.com/ElementsProject/rust-elements/pull/243) pset: blind: return ephemeral private key
+* [#242](https://github.com/ElementsProject/rust-elements/pull/242) Edoc: fix CheckHrpstring::new reference
+* [#236](https://github.com/ElementsProject/rust-elements/pull/236) chore: fix some minor issues in comments
+* [#230](https://github.com/ElementsProject/rust-elements/pull/230) ci: add lockfile and use rust-bitcoin-maintainer-tools CI setup
+* [#228](https://github.com/ElementsProject/rust-elements/pull/228) Enable a ton of pedantic clippy lints
+
+# 0.25.2 - 2025-04-18
+
+* [#226](https://github.com/ElementsProject/rust-elements/pull/226) elip102: rename from elip101
+* [#225](https://github.com/ElementsProject/rust-elements/pull/225) Make AssetId::from_inner a const function
+* [#224](https://github.com/ElementsProject/rust-elements/pull/224) pset: input: insert non-pset proprietary keys
+* [#223](https://github.com/ElementsProject/rust-elements/pull/223) clippy: fix for new rust stable
+* [#195](https://github.com/ElementsProject/rust-elements/pull/195) Fix WASM build and add a job in CI
+* [#222](https://github.com/ElementsProject/rust-elements/pull/222) elementsd-tests: blind asset issuance based on node version
+* [#220](https://github.com/ElementsProject/rust-elements/pull/220) tx: discountct: add missing testcase
+* [#221](https://github.com/ElementsProject/rust-elements/pull/221) ci: fixes for rust stable clippy, and rust 1.56.1 compilation
+
+# 0.25.1 - 2024-10-24
+
+* [#218](https://github.com/ElementsProject/rust-elements/pull/218) discount: fix weight calculation
+
+# 0.25.0 - 2024-09-23
+
+* [#216](https://github.com/ElementsProject/rust-elements/pull/216) add Address::is_liquid
+* [#215](https://github.com/ElementsProject/rust-elements/pull/215) docs: add a bunch of paragraph breaks.
+* [#213](https://github.com/ElementsProject/rust-elements/pull/213) ELIP-0101: rename from LiquiDEX
+* [#212](https://github.com/ElementsProject/rust-elements/pull/212) Stop implementing elements::Encodable with bitcoin::Encodable
+* [#210](https://github.com/ElementsProject/rust-elements/pull/210) Address err refactor
+* [#209](https://github.com/ElementsProject/rust-elements/pull/209) upgrade to bitcoin 0.32
+* [#207](https://github.com/ElementsProject/rust-elements/pull/207) Add elip_liquidex module
+* [#206](https://github.com/ElementsProject/rust-elements/pull/206) pset: elip100: add and get token metadata
+* [#204](https://github.com/ElementsProject/rust-elements/pull/204) tx: add discount_weight and discount_vsize
+* [#203](https://github.com/ElementsProject/rust-elements/pull/203) transaction: range-check pegin data when parsing
+* [#201](https://github.com/ElementsProject/rust-elements/pull/201) pset: add optional asset blinding factor to input and output
+* [#200](https://github.com/ElementsProject/rust-elements/pull/200) pset: input: add blinded issuance flag
+* [#199](https://github.com/ElementsProject/rust-elements/pull/199) pset: input: add explicit amount and asset, and their proofs
+
+# 0.24.1 - 2024-01-30
+
+* [#196](https://github.com/ElementsProject/rust-elements/pull/196) Add constructor to `FullParams`
+
+# 0.24.0 - 2024-01-12
+
+* [#188](https://github.com/ElementsProject/rust-elements/pull/188) Update rust-bitcoin to 0.31.0, and associated dependencies
+* [#186](https://github.com/ElementsProject/rust-elements/pull/186) Updated doc for impl Value blind method - returns blinded value*
+* [#185](https://github.com/ElementsProject/rust-elements/pull/185) Exposed RangeProofMessage publically
+* [#183](https://github.com/ElementsProject/rust-elements/pull/183) elip100: add missing AssetMetadata::new method
+* [#182](https://github.com/ElementsProject/rust-elements/pull/182) ELIP-0100 implementation
+* [#178](https://github.com/ElementsProject/rust-elements/pull/178) pset: fix remove_output
+* [#177](https://github.com/ElementsProject/rust-elements/pull/177) rename pset::str::Error to ParseError and expose it
+* [#176](https://github.com/ElementsProject/rust-elements/pull/176) Remove slip77
+* [#175](https://github.com/ElementsProject/rust-elements/pull/175) Add to and from base64 string to pset
+* [#173](https://github.com/ElementsProject/rust-elements/pull/173) Fix examples
+* [#171](https://github.com/ElementsProject/rust-elements/pull/171) Create explicit empty and null values for some types
+
+# 0.23.0 - 2023-06-18
+
+* [#167](https://github.com/ElementsProject/rust-elements/pull/167) Implement Ord for Transaction
+* [#168](https://github.com/ElementsProject/rust-elements/pull/168) add Height::ZERO associated constant
+* [#168](https://github.com/ElementsProject/rust-elements/pull/169) rename all Sighash types downcasing the middle "h", for example: SigHash -> Sighash
+
+# 0.22.0 - 2023-06-08
+
+* [#159](https://github.com/ElementsProject/rust-elements/pull/159) Update `TapTweak`, and `schnorr` module generally, to match rust-bitcoin
+* [#160](https://github.com/ElementsProject/rust-elements/pull/160) Make `Prevouts` generic over type of `TxOut`
+* [#161](https://github.com/ElementsProject/rust-elements/pull/161) Add `Transaction::vsize` method
+* [#157](https://github.com/ElementsProject/rust-elements/pull/157) dynafed: extract `FullParams` from `Params`
+* [#166](https://github.com/ElementsProject/rust-elements/pull/166) **Update bitcoin dependency to 0.30.0 and secp256k1-zkp dependency to 0.9.1**
 
 # 0.21.1 - 2022-10-21
 
@@ -22,7 +136,7 @@
 - `Block`, `BlockHeader`, `PeginData`, `PegoutData` loose the Default impl
 - update rust-bitcoin to 0.29.1
 - update secp256k1-zkp to 0.7.0
-- update bitcoin_hases to 0.11.0
+- update bitcoin_hashes to 0.11.0
 
 # 0.19.2 - 2022-06-16
 
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
new file mode 100644
index 00000000..1211fd24
--- /dev/null
+++ b/Cargo-recent.lock
@@ -0,0 +1,892 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "base58ck"
+version = "0.1.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "365c0acd5b2e8dd0111a46c4faea83fb3cfb6e39a49a7c73a06e090db7b2eff0"
+dependencies = [
+ "bitcoin_hashes 0.14.101",
+]
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "bech32"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d965446196e3b7decd44aa7ee49e31d630118f90ef12f97900f262eb915c951d"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitcoin"
+version = "0.32.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0ce8bd5baaa0d303a19915a6d93afed161f528654e42da2a7a97d05c59499a"
+dependencies = [
+ "base58ck",
+ "base64 0.21.7",
+ "bech32",
+ "bitcoin-consensus-encoding",
+ "bitcoin-io",
+ "bitcoin-units",
+ "bitcoin_hashes 0.14.101",
+ "hex-conservative 0.2.2",
+ "hex_lit",
+ "secp256k1",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-consensus-encoding"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "207311705279250ba465076a1bac4b1ac982855fff73fc5f67e22158ac58cdc9"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative 1.1.0",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d573f4cf32996a8dce612e4348cece65a241f1882ed594047c9ba348e8869fa5"
+
+[[package]]
+name = "bitcoin-io"
+version = "0.1.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb5de036369d1ac59d3c1819ebc4d850f89466f5401c571a285b6ed564a4cb78"
+dependencies = [
+ "bitcoin-consensus-encoding",
+]
+
+[[package]]
+name = "bitcoin-private"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73290177011694f38ec25e165d0387ab7ea749a4b81cd4c80dae5988229f7a57"
+
+[[package]]
+name = "bitcoin-units"
+version = "0.1.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cb95693f371d089a4b5b6fc41c6f3ea6e01ee8c15388335dfac8ea685173b51"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative 0.2.2",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a67800fcf7f3ca52f7796d4466948a424326b225950c79d1e76d0458760bb25d"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "hex-conservative 1.1.0",
+ "serde",
+]
+
+[[package]]
+name = "bitcoincore-rpc"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aedd23ae0fd321affb4bbbc36126c6f49a32818dc6b979395d24da8c9d4e80ee"
+dependencies = [
+ "bitcoincore-rpc-json",
+ "jsonrpc",
+ "log",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "bitcoincore-rpc-json"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8909583c5fab98508e80ef73e5592a651c954993dc6b7739963257d19f0e71a"
+dependencies = [
+ "bitcoin",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "bitcoind"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce6620b7c942dbe28cc49c21d95e792feb9ffd95a093205e7875ccfa69c2925"
+dependencies = [
+ "anyhow",
+ "bitcoincore-rpc",
+ "log",
+ "tempfile",
+ "which",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cc"
+version = "1.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d487aa071b5f64da6f19a3e848e3578944b726ee5a4854b82172f02aa876bfdc"
+dependencies = [
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elements"
+version = "0.27.0"
+dependencies = [
+ "bech32",
+ "bincode",
+ "bitcoin",
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "bitcoin_hashes 1.1.0",
+ "getrandom 0.2.16",
+ "hex-conservative 1.1.0",
+ "rand",
+ "rand_chacha",
+ "secp256k1-zkp",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "serde_test",
+]
+
+[[package]]
+name = "elements-fuzz"
+version = "0.0.1"
+dependencies = [
+ "elements",
+ "libfuzzer-sys",
+]
+
+[[package]]
+name = "elementsd"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46bf79f591aad9ce61b72839ba640a8721c8293c2d706b989f9f14fc205efda"
+dependencies = [
+ "bitcoind",
+]
+
+[[package]]
+name = "elementsd-tests"
+version = "0.1.0"
+dependencies = [
+ "bitcoin",
+ "elements",
+ "elementsd",
+ "rand",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
+]
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex-conservative"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7289f6b628ce69fb1a371d0fdcf8ff38cd93ec00e3010eb055d1e044998c8d1"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex_lit"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.3",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "jsonrpc"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3662a38d341d77efecb73caf01420cfa5aa63c0253fd7bc05289ef9f6616e1bf"
+dependencies = [
+ "base64 0.13.1",
+ "minreq",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.174"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f12a681b7dd8ce12bff52488013ba614b869148d54dd79836ab85aafdd53f08d"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "minreq"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84885312a86831bff4a3cb04a1e54a3f698407e3274c83249313f194d3e0b678"
+dependencies = [
+ "log",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rustix"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "secp256k1"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
+dependencies = [
+ "bitcoin_hashes 0.14.101",
+ "rand",
+ "secp256k1-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "secp256k1-zkp"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a44aed3002b5ae975f8624c5df3a949cfbf00479e18778b6058fcd213b76e3"
+dependencies = [
+ "bitcoin-private",
+ "rand",
+ "secp256k1",
+ "secp256k1-zkp-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1-zkp-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57f08b2d0b143a22e07f798ae4f0ab20d5590d7c68e0d090f2088a48a21d1654"
+dependencies = [
+ "cc",
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ad7872ff6e6c2a9221f4c1abe681e7eefc56ca5b3e87196afbfc717d141dc8"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.140"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_test"
+version = "1.0.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f901ee573cab6b3060453d2d5f0bae4e6d628c23c0a962ff9b5f1d7c8d4f1ed"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.3",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "which"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+dependencies = [
+ "either",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 909f550d..8abc3df0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "elements"
-version = "0.21.1"
+version = "0.27.0"
 authors = ["Andrew Poelstra <apoelstra@blockstream.com>"]
 description = "Library with support for de/serialization, parsing and executing on data structures and network messages related to Elements"
 license = "CC0-1.0"
@@ -8,47 +8,49 @@ homepage = "https://github.com/ElementsProject/rust-elements/"
 repository = "https://github.com/ElementsProject/rust-elements/"
 documentation = "https://docs.rs/elements/"
 edition = "2018"
+rust-version = "1.74.0"
+
+[workspace.metadata.rbmt.toolchains]
+nightly = "nightly-2026-07-23"
+stable = "1.97.1"
 
 [features]
-default = [ "json-contract" ]
-integration = [ "elementsd" ]
+default = ["json-contract"]
 
-json-contract = [ "serde_json" ]
+json-contract = ["serde_json"]
 "serde" = [
+    "dep:serde",
+    "bitcoin/serde",
     "bitcoin/serde",
-    "secp256k1-zkp/use-serde",
-    "actual-serde"
+    "hashes/serde",
+    "secp256k1-zkp/serde",
 ]
-"fuzztarget" = []
+base64 = ["bitcoin/base64"]
 
 [dependencies]
-bitcoin = "0.29.1"
-secp256k1-zkp = { version = "0.7.0", features = [ "global-context", "bitcoin_hashes" ] }
-slip21 = "0.2.0"
-
-# While this dependency is included in bitcoin, we need this to use the macros.
-# We should probably try keep this one in sync with the bitcoin version,
-# to avoid requiring two version of bitcoin_hashes.
-bitcoin_hashes = "0.11.0"
+bech32 = "0.11.0"
+bitcoin = { version = "0.32.102", default-features = false, features = [ "encoding", "std" ] }
+encoding = { package = "bitcoin-consensus-encoding", version = "1.1.0", default-features = false, features = [ "hex", "std" ] }
+hashes = { package = "bitcoin_hashes", version = "1.1", features = [ "hex" ] }
+internals = { package = "bitcoin-internals", version = "0.6" }
+secp256k1-zkp = { version = "0.11.0", features = ["global-context", "hashes"] }
 
 # Used for ContractHash::from_json_contract.
 serde_json = { version = "1.0", optional = true }
+serde = { version = "1.0.103", features = [ "derive" ], optional = true }
+hex = { package = "hex-conservative", version = "1.1.0" }
 
-actual-serde = { package="serde", version = "1.0", features=["derive"], optional = true }
 
-# This should be an optional dev-dependency (only needed for integration tests),
-# but dev-dependency cannot be optional, and without optionality older toolchain try to compile it and fails
-elementsd = {version = "0.6.0", features=["0_21_0","bitcoind_22_0"], optional = true }
+[target.wasm32-unknown-unknown.dev-dependencies]
+getrandom = { version = "0.2", features = ["js"] }
 
 [dev-dependencies]
 rand = "0.8"
 rand_chacha = "0.3"
-serde_test = "1.0"
+serde_test = "1.0.19"
 serde_json = "1.0"
-serde_cbor = "0.8"   # older than latest version to support 1.41.1
-ryu = "<1.0.5"
+serde_cbor = "0.8"    # older than latest version to support 1.41.1
 bincode = "1.3"
-base64 = "0.13.0"
 
 [[example]]
 name = "pset_blind_coinjoin"
@@ -58,3 +60,140 @@ name = "raw_blind"
 
 [[example]]
 name = "tx"
+
+[workspace]
+members = ["elementsd-tests", "fuzz"]
+
+[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.
+uninlined_format_args = "allow" # This is a subjective style choice.
+float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
+match_bool = "allow" # Adds extra indentation and LOC.
+match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
+must_use_candidate = "allow" # Useful for audit but many false positives.
+similar_names = "allow" # Too many (subjectively) false positives.
+struct_field_names = "allow" # Dumb
+# 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_enums = "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"
+fn_params_excessive_bools = "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_wildcard_for_single_variants = "warn"
+maybe_infinite_iter = "warn"
+mismatching_type_param_order = "warn"
+missing_errors_doc = "allow" # FIXME this triggers 184 times; we should fix most
+missing_fields_in_debug = "warn"
+missing_panics_doc = "allow" # FIXME this one has 40 triggers
+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"
+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"
+too_many_lines = "allow" # FIXME 14 triggers for this lint; probably most should be fixed
+transmute_ptr_to_ptr = "warn"
+trivially_copy_pass_by_ref = "warn"
+unchecked_time_subtraction = "warn"
+unicode_not_nfc = "warn"
+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"
+
+[package.metadata.rbmt.lint]
+allowed_duplicates = [
+    "bitcoin_hashes",
+    "hex-conservative",
+]
+
+[package.metadata.rbmt.prerelease]
+enabled = true
diff --git a/README.md b/README.md
index f53f3538..e1c8aaf3 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,6 @@ structures and network messages related to Elements
 
 [Documentation](https://docs.rs/elements/)
 
-
 ## Minimum Supported Rust Version (MSRV)
 
-This library should always compile with any combination of features on **Rust 1.41.1**.
+This library should always compile with any combination of features on **Rust 1.74.0**.
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 00000000..c4931941
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1,2 @@
+avoid-breaking-exported-api = true
+large-error-threshold = 192 # default 128 complains about two public keys in RangeProofMessageError
diff --git a/contrib/crates.sh b/contrib/crates.sh
new file mode 100755
index 00000000..d3cb8b40
--- /dev/null
+++ b/contrib/crates.sh
@@ -0,0 +1,9 @@
+# Sourced by `rust-bitcoin-maintainer-tools/ci/run_task.sh`.
+#
+# 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
+
+CRATES=(. elementsd-tests)
\ No newline at end of file
diff --git a/contrib/extra_tests.sh b/contrib/extra_tests.sh
new file mode 100755
index 00000000..404b7505
--- /dev/null
+++ b/contrib/extra_tests.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+set -ex
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# Make all cargo invocations verbose.
+export CARGO_TERM_VERBOSE=true
+
+# Set to false to turn off verbose output.
+flag_verbose=true
+
+main() {
+    source_test_vars            # Get feature list.
+
+    BITCOIND_EXE_DEFAULT="$(git rev-parse --show-toplevel)/elementsd-tests/bin/bitcoind"
+    ELEMENTSD_EXE_DEFAULT="$(git rev-parse --show-toplevel)/elementsd-tests/bin/elementsd"
+
+    cd elementsd-tests
+    BITCOIND_EXE=${BITCOIND_EXE:=${BITCOIND_EXE_DEFAULT}} \
+    ELEMENTSD_EXE=${ELEMENTSD_EXE:=${ELEMENTSD_EXE_DEFAULT}} \
+    cargo --locked test
+    cd ..
+}
+
+# ShellCheck can't follow non-constant source, `test_vars_script` is correct.
+# shellcheck disable=SC1090
+source_test_vars() {
+    local test_vars_script="$REPO_DIR/contrib/test_vars.sh"
+
+    verbose_say "Sourcing $test_vars_script"
+
+    if [ -e "$test_vars_script" ]; then
+        # Set crate specific variables.
+        . "$test_vars_script"
+    else
+        err "Missing $test_vars_script"
+    fi
+}
+
+say() {
+    echo "extra_tests: $1"
+}
+
+verbose_say() {
+    if [ "$flag_verbose" = true ]; then
+	say "$1"
+    fi
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/contrib/test.sh b/contrib/test.sh
deleted file mode 100755
index d13bc25c..00000000
--- a/contrib/test.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/sh -ex
-
-FEATURES="serde"
-
-# Use toolchain if explicitly specified
-if [ -n "$TOOLCHAIN" ]
-then
-    alias cargo="cargo +$TOOLCHAIN"
-fi
-
-# Test without any features first
-cargo test --verbose --no-default-features
-# Then test with the default features
-cargo test --verbose
-
-# Also build and run each example to catch regressions
-cargo build --examples
-# run all examples
-run-parts ./target/debug/examples
-
-# Test each feature
-for feature in ${FEATURES}
-do
-    cargo test --verbose --features="$feature"
-done
-
-# Fuzz if told to
-if [ "$DO_FUZZ" = true ]
-then
-    (
-        cd fuzz
-        cargo test --verbose
-        ./travis-fuzz.sh
-    )
-fi
-
-# Do integration test if told to
-if [ "$DO_INTEGRATION" = true ]
-then
-    (
-        cargo test --features integration
-    )
-fi
diff --git a/contrib/test_vars.sh b/contrib/test_vars.sh
new file mode 100644
index 00000000..d4c49ec8
--- /dev/null
+++ b/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="json-contract serde base64"
+
+# Run these examples.
+EXAMPLES="$(cargo metadata --no-deps --format-version 1 |jq -r '.packages | .[] | .targets | .[] | select(.kind == ["example"]) | .name + ":"')"
diff --git a/elementsd-tests/Cargo.toml b/elementsd-tests/Cargo.toml
new file mode 100644
index 00000000..d08aa099
--- /dev/null
+++ b/elementsd-tests/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "elementsd-tests"
+version = "0.1.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+edition = "2018"
+rust-version = "1.74.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bitcoin = "0.32.2"
+elements = {path = "../", features = ["base64"]}
+elementsd = "0.11.0"
+rand = "0.8"
+
+[package.metadata.rbmt.lint]
+# FIXME the bulk of these are because elementsd/bitcoind is much older than rust-bitcoin.
+allowed_duplicates = [
+    "bitcoin_hashes",
+    "bitcoin-internals",
+    "hex-conservative",
+    "base64",
+    "getrandom",
+    "wasi",
+    "windows-sys",
+    "windows-targets",
+    "windows_aarch64_gnullvm",
+    "windows_aarch64_msvc",
+    "windows_aarch64_gnu",
+    "windows_i686_gnullvm",
+    "windows_i686_msvc",
+    "windows_i686_gnu",
+    "windows_x86_64_gnullvm",
+    "windows_x86_64_msvc",
+    "windows_x86_64_gnu",
+]
diff --git a/elementsd-tests/bin/bitcoind b/elementsd-tests/bin/bitcoind
new file mode 100755
index 00000000..39d71939
Binary files /dev/null and b/elementsd-tests/bin/bitcoind differ
diff --git a/elementsd-tests/bin/elementsd b/elementsd-tests/bin/elementsd
new file mode 100755
index 00000000..0776b02b
Binary files /dev/null and b/elementsd-tests/bin/elementsd differ
diff --git a/elementsd-tests/src/lib.rs b/elementsd-tests/src/lib.rs
new file mode 100644
index 00000000..8806e583
--- /dev/null
+++ b/elementsd-tests/src/lib.rs
@@ -0,0 +1,165 @@
+#[cfg(test)]
+mod pset;
+#[cfg(test)]
+mod taproot;
+
+use elementsd::bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
+use elementsd::bitcoincore_rpc::RpcApi;
+#[cfg(test)]
+use elementsd::bitcoind::{self, BitcoinD};
+use elementsd::ElementsD;
+use std::str::FromStr;
+
+#[allow(dead_code)]
+trait Call {
+    fn call(&self, cmd: &str, args: &[Value]) -> Value;
+    fn decode_psbt(&self, psbt: &str) -> Option<Value>;
+    fn get_new_address(&self) -> String;
+    fn get_pegin_address(&self) -> (String, String);
+    fn wallet_create_funded_psbt(&self, address: &str) -> String;
+    fn expected_next(&self, psbt: &str) -> String;
+    fn wallet_process_psbt(&self, psbt: &str) -> String;
+    fn finalize_psbt(&self, psbt: &str) -> String;
+    fn test_mempool_accept(&self, hex: &str) -> bool;
+    fn get_first_prevout(&self) -> elements::OutPoint;
+    fn generate(&self, blocks: u32);
+    fn get_balances(&self) -> Value;
+
+    fn send_to_address(&self, addr: &str, amt: &str) -> String;
+    fn get_transaction(&self, txid: &str) -> String;
+    fn get_block_hash(&self, id: u32) -> String;
+    fn send_raw_transaction(&self, hex: &str) -> String;
+}
+
+impl Call for ElementsD {
+    fn call(&self, cmd: &str, args: &[Value]) -> Value {
+        match self.client().call::<Value>(cmd, args) {
+            Ok(v) => v,
+            Err(e) => panic!("error {} while calling {} with {:?}", e, cmd, args),
+        }
+    }
+
+    fn decode_psbt(&self, psbt: &str) -> Option<Value> {
+        self.client()
+            .call::<Value>("decodepsbt", &[psbt.into()])
+            .ok()
+    }
+
+    fn get_new_address(&self) -> String {
+        self.call("getnewaddress", &[])
+            .as_str()
+            .unwrap()
+            .to_string()
+    }
+
+    fn get_pegin_address(&self) -> (String, String) {
+        let value = self.call("getpeginaddress", &[]);
+        let mainchain_address = value.get("mainchain_address").unwrap();
+        let mainchain_address = mainchain_address.as_str().unwrap().to_string();
+        let claim_script = value.get("claim_script").unwrap();
+        let claim_script = claim_script.as_str().unwrap().to_string();
+        (mainchain_address, claim_script)
+    }
+
+    fn wallet_create_funded_psbt(&self, address: &str) -> String {
+        let value = self.call(
+            "walletcreatefundedpsbt",
+            &[json!([]), json!([{address.to_string(): "1"}])],
+        );
+        value.get("psbt").unwrap().as_str().unwrap().to_string()
+    }
+
+    fn expected_next(&self, base64: &str) -> String {
+        let value = self.call("analyzepsbt", &[base64.into()]);
+        value.get("next").unwrap().as_str().unwrap().to_string()
+    }
+
+    fn wallet_process_psbt(&self, base64: &str) -> String {
+        let value = self.call("walletprocesspsbt", &[base64.into()]);
+        value.get("psbt").unwrap().as_str().unwrap().to_string()
+    }
+
+    fn finalize_psbt(&self, base64: &str) -> String {
+        let value = self.call("finalizepsbt", &[base64.into()]);
+        value.get("hex").unwrap().as_str().unwrap().to_string()
+    }
+
+    fn test_mempool_accept(&self, hex: &str) -> bool {
+        let result = self.call("testmempoolaccept", &[json!([hex])]);
+        let allowed = result.get(0).unwrap().get("allowed");
+        allowed.unwrap().as_bool().unwrap()
+    }
+
+    fn get_first_prevout(&self) -> elements::OutPoint {
+        let value = self.call("listunspent", &[]);
+        let first = value.get(0).unwrap();
+        let txid = first.get("txid").unwrap().as_str().unwrap();
+        let vout = first.get("vout").unwrap().as_u64().unwrap();
+
+        elements::OutPoint::new(elements::Txid::from_str(txid).unwrap(), vout as u32)
+    }
+
+    fn generate(&self, blocks: u32) {
+        let address = self.get_new_address();
+        let _value = self.call("generatetoaddress", &[blocks.into(), address.into()]);
+    }
+
+    fn get_balances(&self) -> Value {
+        self.call("getbalances", &[])
+    }
+
+    fn get_transaction(&self, txid: &str) -> String {
+        self.call("gettransaction", &[txid.into()])["hex"]
+            .as_str()
+            .unwrap()
+            .to_string()
+    }
+
+    fn send_to_address(&self, addr: &str, amt: &str) -> String {
+        self.call("sendtoaddress", &[addr.into(), amt.into()])
+            .as_str()
+            .unwrap()
+            .to_string()
+    }
+
+    fn send_raw_transaction(&self, tx: &str) -> String {
+        self.call("sendrawtransaction", &[tx.into()])
+            .as_str()
+            .unwrap()
+            .to_string()
+    }
+
+    fn get_block_hash(&self, id: u32) -> String {
+        self.call("getblockhash", &[id.into()])
+            .as_str()
+            .unwrap()
+            .to_string()
+    }
+}
+
+#[cfg(test)]
+fn setup(validate_pegin: bool) -> (ElementsD, Option<BitcoinD>) {
+    let mut bitcoind = None;
+    if validate_pegin {
+        let bitcoind_exe = bitcoind::exe_path().unwrap();
+        let bitcoind_conf = bitcoind::Conf::default();
+        bitcoind = Some(bitcoind::BitcoinD::with_conf(&bitcoind_exe, &bitcoind_conf).unwrap());
+    }
+
+    let conf = elementsd::Conf::new(bitcoind.as_ref());
+
+    let elementsd = ElementsD::with_conf(elementsd::exe_path().unwrap(), &conf).unwrap();
+
+    let create = elementsd.call("createwallet", &["wallet".into()]);
+    assert_eq!(create.get("name").unwrap(), "wallet");
+
+    let rescan = elementsd.call("rescanblockchain", &[]);
+    assert_eq!(rescan.get("stop_height").unwrap(), 0);
+
+    let balances = elementsd.call("getbalances", &[]);
+    let mine = balances.get("mine").unwrap();
+    let trusted = mine.get("trusted").unwrap();
+    assert_eq!(trusted.get("bitcoin").unwrap(), 21.0);
+
+    (elementsd, bitcoind)
+}
diff --git a/elementsd-tests/src/pset.rs b/elementsd-tests/src/pset.rs
new file mode 100644
index 00000000..7b907278
--- /dev/null
+++ b/elementsd-tests/src/pset.rs
@@ -0,0 +1,164 @@
+
+extern crate elements;
+
+extern crate elementsd;
+extern crate rand;
+
+use crate::{setup, Call};
+
+use bitcoin::{self, Address, Amount};
+use elements::encode::serialize;
+use elements::hex::DisplayHex as _;
+use elements::pset::PartiallySignedTransaction;
+use elements::{AssetId, ContractHash};
+use elementsd::bitcoincore_rpc::jsonrpc::serde_json::json;
+use elementsd::bitcoincore_rpc::RpcApi;
+use elementsd::ElementsD;
+use rand::distributions::{Distribution, Uniform};
+use std::str::FromStr;
+
+#[test]
+fn tx_unblinded() {
+    let (elementsd, _bitcoind) = setup(false);
+
+    let address = elementsd.get_new_address();
+    let psbt_base64 = elementsd.wallet_create_funded_psbt(&address);
+    assert_eq!(elementsd.expected_next(&psbt_base64), "blinder");
+    psbt_rtt(&elementsd, &psbt_base64);
+}
+
+#[test]
+fn tx_blinded() {
+    let (elementsd, _bitcoind) = setup(false);
+
+    let address = elementsd.get_new_address();
+    let psbt_base64 = elementsd.wallet_create_funded_psbt(&address);
+    assert_eq!(elementsd.expected_next(&psbt_base64), "blinder");
+    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
+    assert_eq!(elementsd.expected_next(&psbt_base64), "finalizer");
+    psbt_rtt(&elementsd, &psbt_base64);
+
+    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
+    assert!(elementsd.test_mempool_accept(&tx_hex));
+}
+
+#[test]
+fn tx_issuance() {
+    let (elementsd, _bitcoind) = setup(false);
+
+    // Divide out minor and patch version
+    let is_21 = elementsd.client().version().expect("obtain version") / 10000 == 21;
+
+    let address_asset = elementsd.get_new_address();
+    let address_reissuance = elementsd.get_new_address();
+    let address_lbtc = elementsd.get_new_address();
+    let prevout = elementsd.get_first_prevout();
+
+    let contract_hash = ContractHash::from_byte_array([0u8; 32]);
+    let entropy = AssetId::generate_asset_entropy(prevout, contract_hash);
+    let asset_id = AssetId::from_entropy(entropy);
+    let reissuance_id = AssetId::reissuance_token_from_entropy(entropy, is_21);
+
+    let value = elementsd.call(
+            "createpsbt",
+            &[
+                json!([{ "txid": prevout.txid.to_string(), "vout": prevout.vout, "issuance_amount": 1000, "issuance_tokens": 1, "blind_reissuance": is_21}]),
+                json!([
+                    {address_asset: "1000", "asset": asset_id.to_string(), "blinder_index": 0},
+                    {address_reissuance: "1", "asset": reissuance_id.to_string(), "blinder_index": 0},
+                    {address_lbtc: "20.9", "blinder_index": 0},
+                    {"fee": "0.1" }
+                ]),
+                0.into(),
+                false.into(),
+            ],
+        );
+    let psbt_base64 = value.as_str().unwrap().to_string();
+
+    assert_eq!(elementsd.expected_next(&psbt_base64), "updater");
+    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
+    assert_eq!(elementsd.expected_next(&psbt_base64), "finalizer");
+    psbt_rtt(&elementsd, &psbt_base64);
+
+    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
+    assert!(elementsd.test_mempool_accept(&tx_hex));
+}
+
+#[test]
+#[ignore] // TODO this fails because elements decodepsbt is not printing TxOut::asset (PSET_IN_WITNESS_UTXO)
+fn tx_pegin() {
+    let (elementsd, bitcoind) = setup(true);
+    let bitcoind = bitcoind.unwrap();
+    let btc_addr = bitcoind.client.get_new_address(None, None).unwrap()
+        .assume_checked();
+    let address_lbtc = elementsd.get_new_address();
+    bitcoind.client.generate_to_address(101, &btc_addr).unwrap();
+    let (pegin_address, claim_script) = elementsd.get_pegin_address();
+    let address = Address::from_str(&pegin_address).unwrap()
+        .assume_checked();
+    let amount = Amount::from_sat(100_000_000);
+    let txid = bitcoind
+        .client
+        .send_to_address(&address, amount, None, None, None, None, None, None)
+        .unwrap();
+    let tx = bitcoind.client.get_raw_transaction(&txid, None).unwrap();
+    let tx_bytes = bitcoin::consensus::serialize(&tx);
+    let vout = tx
+        .output
+        .iter()
+        .position(|o| {
+            let addr = Address::from_script(&o.script_pubkey, bitcoin::Network::Regtest);
+            addr.unwrap().to_string() == pegin_address
+        })
+        .unwrap();
+
+    bitcoind.client.generate_to_address(101, &btc_addr).unwrap();
+    let proof = bitcoind.client.get_tx_out_proof(&[txid], None).unwrap();
+    elementsd.generate(2);
+    let inputs = json!([ {"txid":txid, "vout": vout,"pegin_bitcoin_tx": tx_bytes.to_lower_hex_string(), "pegin_txout_proof": proof.to_lower_hex_string(), "pegin_claim_script": claim_script } ]);
+    let outputs = json!([
+        {address_lbtc: "0.9", "blinder_index": 0},
+        {"fee": "0.1" }
+    ]);
+    let value = elementsd.call("createpsbt", &[inputs, outputs, 0.into(), false.into()]);
+    let psbt_base64 = value.as_str().unwrap().to_string();
+    assert_eq!(elementsd.expected_next(&psbt_base64), "updater");
+    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
+    assert_eq!(elementsd.expected_next(&psbt_base64), "extractor");
+
+    psbt_rtt(&elementsd, &psbt_base64);
+
+    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
+    assert!(elementsd.test_mempool_accept(&tx_hex));
+}
+
+fn rtt(base64: &str) -> String {
+    let pset: PartiallySignedTransaction = base64.parse().unwrap();
+    pset.to_string()
+}
+
+fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
+    use bitcoin::base64::prelude::{Engine as _, BASE64_STANDARD};
+    let a = elementsd.decode_psbt(base64).unwrap();
+
+    let b_psbt: PartiallySignedTransaction = base64.parse().unwrap();
+    let mut b_bytes = serialize(&b_psbt);
+    let b_base64 = BASE64_STANDARD.encode(&b_bytes);
+    let b = elementsd.decode_psbt(&b_base64).unwrap();
+
+    assert_eq!(a, b);
+
+    let mut rng = rand::thread_rng();
+    let die = Uniform::from(0..b_bytes.len());
+    for _ in 0..1_000 {
+        let i = die.sample(&mut rng);
+        // ensuring decode prints all data inside psbt, randomly changing a byte,
+        // if the results is still decodable it should not be equal to initial value
+        b_bytes[i] = b_bytes[i].wrapping_add(1);
+        let base64 = BASE64_STANDARD.encode(&b_bytes);
+        if let Some(decoded) = elementsd.decode_psbt(&base64) {
+            assert_ne!(a, decoded, "{} with changed byte {}", b_bytes.as_hex(), i);
+        }
+        b_bytes[i] = b_bytes[i].wrapping_sub(1);
+    }
+}
diff --git a/tests/taproot.rs b/elementsd-tests/src/taproot.rs
similarity index 60%
rename from tests/taproot.rs
rename to elementsd-tests/src/taproot.rs
index be9353e5..364c7230 100644
--- a/tests/taproot.rs
+++ b/elementsd-tests/src/taproot.rs
@@ -1,54 +1,37 @@
-#![cfg(all(test, feature = "integration"))]
-
 extern crate elements;
 
-extern crate bitcoin;
-#[cfg(feature = "integration")]
 extern crate elementsd;
 extern crate rand;
 
-use bitcoin::{Amount, XOnlyPublicKey, KeyPair};
-use elements::bitcoin::hashes::hex::FromHex;
+use crate::{Call, setup};
+
+use bitcoin::key::{XOnlyPublicKey, Keypair};
+use bitcoin::Amount;
+use elements::hex;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::encode::{deserialize, serialize_hex};
-use elements::hashes::Hash;
 use elements::script::Builder;
 use elements::secp256k1_zkp;
-use elements::sighash::{self, SigHashCache};
+use elements::sighash::{self, SighashCache};
 use elements::taproot::{LeafVersion, TapTweakHash, TaprootBuilder, TaprootSpendInfo, TapLeafHash};
 use elements::OutPoint;
 use elements::{
-    confidential, opcodes, AssetIssuance, BlockHash, PackedLockTime, SchnorrSig, SchnorrSigHashType, Script,
+    confidential, opcodes, AssetIssuance, BlockHash, LockTime, SchnorrSig, SchnorrSighashType, Script,
     Sequence, TxInWitness, TxOut, Txid,
 };
 use elements::{AddressParams, Transaction, TxIn, TxOutSecrets};
-use elementsd::bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
-use elementsd::bitcoincore_rpc::RpcApi;
-use elementsd::bitcoind::BitcoinD;
-use elementsd::{bitcoind, ElementsD};
+use elementsd::ElementsD;
 use rand::{rngs, thread_rng};
 use secp256k1_zkp::Secp256k1;
 use std::str::FromStr;
 
 static PARAMS: AddressParams = AddressParams::ELEMENTS;
 
-trait Call {
-    fn call(&self, cmd: &str, args: &[Value]) -> Value;
-    fn decode_psbt(&self, psbt: &str) -> Option<Value>;
-    fn get_new_address(&self) -> String;
-    fn send_to_address(&self, addr: &str, amt: &str) -> String;
-    fn get_transaction(&self, txid: &str) -> String;
-    fn get_block_hash(&self, id: u32) -> String;
-    fn test_mempool_accept(&self, hex: &str) -> bool;
-    fn send_raw_transaction(&self, hex: &str) -> String;
-    fn generate(&self, blocks: u32);
-}
-
 fn gen_keypair(
     secp: &secp256k1_zkp::Secp256k1<secp256k1_zkp::All>,
     rng: &mut rngs::ThreadRng,
-) -> (XOnlyPublicKey, KeyPair) {
-    let keypair = KeyPair::new(secp, rng);
+) -> (XOnlyPublicKey, Keypair) {
+    let keypair = Keypair::new(secp, rng);
     let (pk, _) = XOnlyPublicKey::from_keypair(&keypair);
     (pk, keypair)
 }
@@ -58,10 +41,10 @@ fn gen_keypair(
 struct TapTxOutData {
     _blind_sk: Option<secp256k1_zkp::SecretKey>,
     _blind_pk: Option<secp256k1_zkp::PublicKey>,
-    leaf1_keypair: KeyPair,
+    leaf1_keypair: Keypair,
     _leaf1_pk: XOnlyPublicKey,
     leaf1_script: Script,
-    internal_keypair: KeyPair,
+    internal_keypair: Keypair,
     internal_pk: XOnlyPublicKey,
     spend_info: TaprootSpendInfo,
     utxo: TxOut,
@@ -85,7 +68,7 @@ fn funded_tap_txout(
 
     let (blind_sk, blind_pk) = if blind {
         let sk = secp256k1_zkp::SecretKey::new(&mut thread_rng());
-        let pk = secp256k1_zkp::PublicKey::from_secret_key(&secp, &sk);
+        let pk = secp256k1_zkp::PublicKey::from_secret_key(secp, &sk);
         (Some(sk), Some(pk))
     } else {
         (None, None)
@@ -117,7 +100,7 @@ fn funded_tap_txout(
     elementsd.generate(1);
     let tx_hex = elementsd.get_transaction(&txid_hex);
 
-    let tx = deserialize::<Transaction>(&Vec::<u8>::from_hex(&tx_hex).unwrap()).unwrap();
+    let tx = deserialize::<Transaction>(&hex::decode_to_vec(&tx_hex).unwrap()).unwrap();
 
     let mut outpoint: Option<OutPoint> = None;
     for (i, out) in tx.output.iter().enumerate() {
@@ -160,17 +143,17 @@ fn taproot_spend_test(
     elementsd: &ElementsD,
     secp: &Secp256k1<secp256k1_zkp::All>,
     genesis_hash: BlockHash,
-    sighash_ty: SchnorrSigHashType,
+    sighash_ty: SchnorrSighashType,
     blind_prevout: bool,
     blind_tx: bool,
     key_spend: bool,
 ) {
-    let test_data = funded_tap_txout(&elementsd, &secp, blind_prevout);
+    let test_data = funded_tap_txout(elementsd, secp, blind_prevout);
 
     // create a new spend that spends the above output
     let mut tx = Transaction {
         version: 2,
-        lock_time: PackedLockTime::ZERO,
+        lock_time: LockTime::ZERO,
         input: vec![],
         output: vec![],
     };
@@ -198,18 +181,18 @@ fn taproot_spend_test(
     if blind_tx {
         // set the nNonce as some confidential key to mark the output for blinding
         let sk = secp256k1_zkp::SecretKey::new(&mut thread_rng());
-        let pk = secp256k1_zkp::PublicKey::from_secret_key(&secp, &sk);
+        let pk = secp256k1_zkp::PublicKey::from_secret_key(secp, &sk);
         tx.output[0].nonce = confidential::Nonce::Confidential(pk);
         tx.blind(
             &mut thread_rng(),
-            &secp,
+            secp,
             &[test_data.txout_secrets],
             false
         )
         .unwrap();
     }
 
-    let mut cache = SigHashCache::new(&tx);
+    let mut cache = SighashCache::new(&tx);
 
     if key_spend {
         // test key spend
@@ -229,18 +212,18 @@ fn taproot_spend_test(
             test_data.internal_pk,
             test_data.spend_info.merkle_root(),
         );
-        let tweak = secp256k1_zkp::Scalar::from_be_bytes(tweak.into_inner()).expect("hash value greater than curve order");
+        let tweak = secp256k1_zkp::Scalar::from_be_bytes(tweak.to_byte_array()).expect("hash value greater than curve order");
         let sig = secp.sign_schnorr(
-            &secp256k1_zkp::Message::from_slice(&sighash_msg[..]).unwrap(),
-            &output_keypair.add_xonly_tweak(&secp, &tweak).unwrap(),
+            &secp256k1_zkp::Message::from_digest(sighash_msg.to_byte_array()),
+            &output_keypair.add_xonly_tweak(secp, &tweak).unwrap(),
         );
 
         let schnorr_sig = SchnorrSig {
-            sig: sig,
+            sig,
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![schnorr_sig.to_vec()];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec());
     } else {
         // script spend
         // try spending using leaf1
@@ -255,7 +238,7 @@ fn taproot_spend_test(
             .unwrap();
 
         let sig = secp.sign_schnorr(
-            &secp256k1_zkp::Message::from_slice(&sighash_msg[..]).unwrap(),
+            &secp256k1_zkp::Message::from_digest(sighash_msg.to_byte_array()),
             &test_data.leaf1_keypair,
         );
 
@@ -263,15 +246,13 @@ fn taproot_spend_test(
         let ctrl_block = test_data.spend_info.control_block(&script_ver).unwrap();
 
         let schnorr_sig = SchnorrSig {
-            sig: sig,
+            sig,
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![
-            schnorr_sig.to_vec(), // witness
-            script_ver.0.into_bytes(), // leaf script
-            ctrl_block.serialize(), // control block
-        ];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec()); // witness
+        tx.input[0].witness.script_witness.push(script_ver.0.into_bytes()); // leaf script
+        tx.input[0].witness.script_witness.push(ctrl_block.serialize()); // control block
     }
 
     let tx_hex = serialize_hex(&tx);
@@ -290,26 +271,26 @@ fn taproot_tests() {
     let genesis_hash = BlockHash::from_str(&genesis_hash_str).unwrap();
 
     let sighash_tys = [
-        SchnorrSigHashType::Default,
-        SchnorrSigHashType::Single,
-        SchnorrSigHashType::SinglePlusAnyoneCanPay,
-        SchnorrSigHashType::None,
-        SchnorrSigHashType::NonePlusAnyoneCanPay,
-        SchnorrSigHashType::All,
-        SchnorrSigHashType::AllPlusAnyoneCanPay,
+        SchnorrSighashType::Default,
+        SchnorrSighashType::Single,
+        SchnorrSighashType::SinglePlusAnyoneCanPay,
+        SchnorrSighashType::None,
+        SchnorrSighashType::NonePlusAnyoneCanPay,
+        SchnorrSighashType::All,
+        SchnorrSighashType::AllPlusAnyoneCanPay,
     ];
 
-    for conf_prevout in [true, false] {
+    for &conf_prevout in &[true, false] {
         // whether the input is blinded
-        for blind in [true, false] {
+        for &blind in &[true, false] {
             // blind the current tx
             if !blind && conf_prevout {
                 // trying to spend a confidential txout to all explicit transactions
                 // This is not possible to do because we need to balance the blinding factors
                 continue;
             }
-            for script_spend in [true, false] {
-                for sighash_ty in sighash_tys {
+            for &script_spend in &[true, false] {
+                for &sighash_ty in &sighash_tys {
                     taproot_spend_test(
                         &elementsd,
                         &secp,
@@ -325,86 +306,3 @@ fn taproot_tests() {
     }
 }
 
-impl Call for ElementsD {
-    fn call(&self, cmd: &str, args: &[Value]) -> Value {
-        self.client().call::<Value>(cmd, args).unwrap()
-    }
-
-    fn decode_psbt(&self, psbt: &str) -> Option<Value> {
-        self.client()
-            .call::<Value>("decodepsbt", &[psbt.into()])
-            .ok()
-    }
-
-    fn get_new_address(&self) -> String {
-        self.call("getnewaddress", &[])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn get_transaction(&self, txid: &str) -> String {
-        self.call("gettransaction", &[txid.into()])["hex"]
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn send_to_address(&self, addr: &str, amt: &str) -> String {
-        self.call("sendtoaddress", &[addr.into(), amt.into()])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn send_raw_transaction(&self, tx: &str) -> String {
-        self.call("sendrawtransaction", &[tx.into()])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn get_block_hash(&self, id: u32) -> String {
-        self.call("getblockhash", &[id.into()])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn generate(&self, blocks: u32) {
-        let address = self.get_new_address();
-        let _value = self.call("generatetoaddress", &[blocks.into(), address.into()]);
-    }
-
-    fn test_mempool_accept(&self, hex: &str) -> bool {
-        let result = self.call("testmempoolaccept", &[json!([hex])]);
-        let allowed = result.get(0).unwrap().get("allowed");
-        allowed.unwrap().as_bool().unwrap()
-    }
-}
-
-fn setup(validate_pegin: bool) -> (ElementsD, Option<BitcoinD>) {
-    let mut bitcoind = None;
-    if validate_pegin {
-        let bitcoind_exe = bitcoind::exe_path().unwrap();
-        let bitcoind_conf = bitcoind::Conf::default();
-        bitcoind = Some(bitcoind::BitcoinD::with_conf(&bitcoind_exe, &bitcoind_conf).unwrap());
-    }
-
-    let conf = elementsd::Conf::new(bitcoind.as_ref());
-
-    let elementsd = ElementsD::with_conf(elementsd::exe_path().unwrap(), &conf).unwrap();
-
-    let create = elementsd.call("createwallet", &["wallet".into()]);
-    assert_eq!(create.get("name").unwrap(), "wallet");
-
-    let rescan = elementsd.call("rescanblockchain", &[]);
-    assert_eq!(rescan.get("stop_height").unwrap(), 0);
-
-    let balances = elementsd.call("getbalances", &[]);
-    let mine = balances.get("mine").unwrap();
-    let trusted = mine.get("trusted").unwrap();
-    assert_eq!(trusted.get("bitcoin").unwrap(), 21.0);
-
-    (elementsd, bitcoind)
-}
diff --git a/examples/pset_blind_coinjoin.rs b/examples/pset_blind_coinjoin.rs
index 6f900de2..0f9931e6 100644
--- a/examples/pset_blind_coinjoin.rs
+++ b/examples/pset_blind_coinjoin.rs
@@ -1,13 +1,14 @@
 //! PSET coinjoin example
-//! 1. Person `A` create a transcation with 1 input and 3 outputs(1 fee output)
-//! 2. Person `B` takes the transcation from A and adds one input and two outputs
+//! 1. Person `A` create a transaction with 1 input and 3 outputs(1 fee output)
+//! 2. Person `B` takes the transaction from A and adds one input and two outputs
 //!    which transact another confidential asset
 //! 3. Person `B` blinds it's own outputs and gives the pset back to A
-//! 4. B completly blinds the transaction
+//! 4. B completely blinds the transaction
 //! 5. B signs the blinded Transaction and sends it back to A
 //! 6. A signs it's input
 //! 7. A finalizes the pset
 //! 8. A extracts and broadcasts the transaction
+//!
 //! During the entire interaction, the output blinding factors for A and B are not
 //! shared with each other.
 extern crate bitcoin;
@@ -17,20 +18,21 @@ extern crate serde_json;
 
 use std::{collections::HashMap, str::FromStr};
 
+use bitcoin::PublicKey;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::{
-    bitcoin::PublicKey, pset::PartiallySignedTransaction as Pset, OutPoint,
+    pset::PartiallySignedTransaction as Pset, OutPoint,
     Script, TxOutSecrets, TxOutWitness, Txid, WScriptHash,
 };
 use elements::{pset, secp256k1_zkp};
 
 use elements::encode::{deserialize, serialize_hex};
-use elements::hashes::hex::FromHex;
 use elements::{confidential, AssetId, TxOut};
+use elements::hex;
 use rand::SeedableRng;
 
 // Assume txouts are simple pay to wpkh
-// and keep the secrets correponding to
+// and keep the secrets corresponding to
 // confidential txouts
 #[derive(Debug, Clone)]
 struct Secrets {
@@ -39,7 +41,7 @@ struct Secrets {
 }
 
 fn deser_pset(psbt_hex: &str) -> Pset {
-    deserialize::<Pset>(&Vec::<u8>::from_hex(psbt_hex).unwrap()).unwrap()
+    deserialize::<Pset>(&hex::decode_to_vec(psbt_hex).unwrap()).unwrap()
 }
 
 fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
@@ -48,38 +50,38 @@ fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
 
     let txout = TxOut {
         asset: deserialize::<confidential::Asset>(
-            &Vec::<u8>::from_hex(&v["assetcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["assetcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         value: deserialize::<confidential::Value>(
-            &Vec::<u8>::from_hex(&v["amountcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["amountcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         nonce: deserialize::<confidential::Nonce>(
-            &Vec::<u8>::from_hex(&v["commitmentnonce"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["commitmentnonce"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
-        script_pubkey: Script::from_hex(&v["scriptPubKey"].as_str().unwrap()).unwrap(),
+        script_pubkey: Script::from_hex_no_prefix(v["scriptPubKey"].as_str().unwrap()).unwrap(),
         witness: TxOutWitness::default(),
     };
 
     let txoutsecrets = Secrets {
-        _sk: bitcoin::PrivateKey::from_wif(&v["skwif"].as_str().unwrap()).unwrap(),
+        _sk: bitcoin::PrivateKey::from_wif(v["skwif"].as_str().unwrap()).unwrap(),
         sec: TxOutSecrets {
-            asset_bf: AssetBlindingFactor::from_str(&v["assetblinder"].as_str().unwrap()).unwrap(),
-            value_bf: ValueBlindingFactor::from_str(&v["amountblinder"].as_str().unwrap()).unwrap(),
+            asset_bf: AssetBlindingFactor::from_str(v["assetblinder"].as_str().unwrap()).unwrap(),
+            value_bf: ValueBlindingFactor::from_str(v["amountblinder"].as_str().unwrap()).unwrap(),
             value: bitcoin::Amount::from_str_in(
-                &v["amount"].as_str().unwrap(),
+                v["amount"].as_str().unwrap(),
                 bitcoin::Denomination::Bitcoin,
             )
             .unwrap()
             .to_sat(),
-            asset: AssetId::from_hex(&v["asset"].as_str().unwrap()).unwrap(),
+            asset: AssetId::from_str(v["asset"].as_str().unwrap()).unwrap(),
         },
     };
 
     let inp = pset::Input::from_prevout(OutPoint::new(
-        Txid::from_str(&v["txid"].as_str().unwrap()).unwrap(),
+        Txid::from_str(v["txid"].as_str().unwrap()).unwrap(),
         v["vout"].as_u64().unwrap() as u32,
     ));
 
diff --git a/examples/raw_blind.rs b/examples/raw_blind.rs
index 74a60643..18a0e974 100644
--- a/examples/raw_blind.rs
+++ b/examples/raw_blind.rs
@@ -5,16 +5,17 @@ extern crate serde_json;
 
 use std::{collections::HashMap, str::FromStr};
 
+use bitcoin::PublicKey;
 use elements::confidential::{AssetBlindingFactor, ValueBlindingFactor};
 use elements::{
-    bitcoin::PublicKey, pset::PartiallySignedTransaction as Pset, Address, AddressParams, OutPoint,
+    pset::PartiallySignedTransaction as Pset, Address, AddressParams, OutPoint,
     Script, TxOutSecrets, TxOutWitness, Txid, WScriptHash,
 };
 use elements::{pset, secp256k1_zkp, SurjectionInput};
 
 use elements::encode::{deserialize, serialize_hex};
-use elements::hashes::hex::FromHex;
 use elements::{confidential, AssetId, TxOut};
+use elements::hex;
 use rand::SeedableRng;
 
 /// Pset example workflow:
@@ -26,7 +27,7 @@ use rand::SeedableRng;
 static PARAMS: AddressParams = AddressParams::ELEMENTS;
 
 // Assume txouts are simple pay to wpkh
-// and keep the secrets correponding to
+// and keep the secrets corresponding to
 // confidential txouts
 #[derive(Debug, Clone)]
 struct Secrets {
@@ -35,7 +36,7 @@ struct Secrets {
 }
 
 fn deser_pset(psbt_hex: &str) -> Pset {
-    deserialize::<Pset>(&Vec::<u8>::from_hex(psbt_hex).unwrap()).unwrap()
+    deserialize::<Pset>(&hex::decode_to_vec(psbt_hex).unwrap()).unwrap()
 }
 
 fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
@@ -44,38 +45,38 @@ fn parse_txout(txout_info: &str) -> (TxOut, Secrets, pset::Input) {
 
     let txout = TxOut {
         asset: deserialize::<confidential::Asset>(
-            &Vec::<u8>::from_hex(&v["assetcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["assetcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         value: deserialize::<confidential::Value>(
-            &Vec::<u8>::from_hex(&v["amountcommitment"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["amountcommitment"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
         nonce: deserialize::<confidential::Nonce>(
-            &Vec::<u8>::from_hex(&v["commitmentnonce"].as_str().unwrap()).unwrap(),
+            &hex::decode_to_vec(v["commitmentnonce"].as_str().unwrap()).unwrap(),
         )
         .unwrap(),
-        script_pubkey: Script::from_hex(&v["scriptPubKey"].as_str().unwrap()).unwrap(),
+        script_pubkey: Script::from_hex_no_prefix(v["scriptPubKey"].as_str().unwrap()).unwrap(),
         witness: TxOutWitness::default(),
     };
 
     let txoutsecrets = Secrets {
-        _sk: bitcoin::PrivateKey::from_wif(&v["skwif"].as_str().unwrap()).unwrap(),
+        _sk: bitcoin::PrivateKey::from_wif(v["skwif"].as_str().unwrap()).unwrap(),
         sec: TxOutSecrets {
-            asset_bf: AssetBlindingFactor::from_str(&v["assetblinder"].as_str().unwrap()).unwrap(),
-            value_bf: ValueBlindingFactor::from_str(&v["amountblinder"].as_str().unwrap()).unwrap(),
+            asset_bf: AssetBlindingFactor::from_str(v["assetblinder"].as_str().unwrap()).unwrap(),
+            value_bf: ValueBlindingFactor::from_str(v["amountblinder"].as_str().unwrap()).unwrap(),
             value: bitcoin::Amount::from_str_in(
-                &v["amount"].as_str().unwrap(),
+                v["amount"].as_str().unwrap(),
                 bitcoin::Denomination::Bitcoin,
             )
             .unwrap()
             .to_sat(),
-            asset: AssetId::from_hex(&v["asset"].as_str().unwrap()).unwrap(),
+            asset: AssetId::from_str(v["asset"].as_str().unwrap()).unwrap(),
         },
     };
 
     let inp = pset::Input::from_prevout(OutPoint::new(
-        Txid::from_str(&v["txid"].as_str().unwrap()).unwrap(),
+        Txid::from_str(v["txid"].as_str().unwrap()).unwrap(),
         v["vout"].as_u64().unwrap() as u32,
     ));
 
@@ -183,7 +184,7 @@ fn main() {
         &mut rng,
         &secp,
         dest_amt,
-        Address::p2wsh(
+        &Address::p2wsh(
             &Script::new_v0_wsh(&dest_wsh),
             Some(dest_blind_pk.inner),
             &PARAMS,
@@ -205,7 +206,7 @@ fn main() {
             &mut rng,
             &secp,
             change_amt,
-            Address::p2wsh(
+            &Address::p2wsh(
                 &Script::new_v0_wsh(&change_wsh),
                 Some(change_blind_pk.inner),
                 &PARAMS,
@@ -279,14 +280,14 @@ fn main() {
     tx.verify_tx_amt_proofs(&secp, &[btc_txout, asset_txout])
         .unwrap();
 
-    let inp0_sig = Vec::<u8>::from_hex("3044022040d1802d6e10da4c27f05eff807550e614b3d2fa20c663dbf1ebf162d3952689022001f477c953b7c543bce877e3297fccb00ef5dba21d427e79c8bfb8522713309801").unwrap();
-    let inp0_pk = bitcoin::PublicKey::from_str(
+    let inp0_sig = hex::hex!("3044022040d1802d6e10da4c27f05eff807550e614b3d2fa20c663dbf1ebf162d3952689022001f477c953b7c543bce877e3297fccb00ef5dba21d427e79c8bfb8522713309801").to_vec();
+    let inp0_pk = PublicKey::from_str(
         "0334c307ad8142e7c8a6bf1ad3552b12fbb860885ea7f2d76c1f49f93a7c4bbbe7",
     )
     .unwrap();
 
-    let inp1_sig = Vec::<u8>::from_hex("3044022017c696503f5e1539fe5cb8dd05f793bd3b6e39f193028a7299a80c94c817a02d022007889009088f46cd9d9f4d137815704170410f53d503b68c1e020292a85b93fa01").unwrap();
-    let inp1_pk = bitcoin::PublicKey::from_str(
+    let inp1_sig = hex::hex!("3044022017c696503f5e1539fe5cb8dd05f793bd3b6e39f193028a7299a80c94c817a02d022007889009088f46cd9d9f4d137815704170410f53d503b68c1e020292a85b93fa01").to_vec();
+    let inp1_pk = PublicKey::from_str(
         "03df8f51c053ba0dfb443cce9793b6dc3339ffb0ce97af4792dade3aae1eb890f6",
     )
     .unwrap();
@@ -304,15 +305,13 @@ fn main() {
 
     // Finalize(TODO in miniscript)
     pset.inputs_mut()[0].partial_sigs.clear();
-    pset.inputs_mut()[0].final_script_witness = Some(vec![
-        inp0_sig,
-        inp0_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[0].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp0_sig);
+    wit.push(inp0_pk.to_bytes());
     pset.inputs_mut()[1].partial_sigs.clear();
-    pset.inputs_mut()[1].final_script_witness = Some(vec![
-        inp1_sig,
-        inp1_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[1].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp1_sig);
+    wit.push(inp1_pk.to_bytes());
     assert_eq!(pset, deser_pset(&tests["finalized"]));
 
     // Extracted tx
diff --git a/examples/tx.rs b/examples/tx.rs
index 0334c5eb..6e889809 100644
--- a/examples/tx.rs
+++ b/examples/tx.rs
@@ -3,19 +3,20 @@ extern crate bitcoin;
 extern crate rand;
 
 
+use std::str::FromStr;
+
 use elements::{Transaction, TxOutWitness};
-use elements::{secp256k1_zkp};
 
 use elements::{AssetId, confidential, TxOut};
-use elements::hashes::hex::FromHex;
 use elements::encode::deserialize;
+use elements::hex;
 
 fn main() {
 
     let secp = secp256k1_zkp::Secp256k1::new();
-    let tx: Transaction = deserialize(&Vec::<u8>::from_hex("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").unwrap()).unwrap();
-    let asset_id = elements::hashes::sha256d::Hash::from_hex("b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23").expect("Valid asset id");
-    let btc_asset = confidential::Asset::Explicit(AssetId::from_slice(&asset_id).unwrap());
+    let tx: Transaction = deserialize(&hex::hex!("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")).unwrap();
+    let asset_id = AssetId::from_str("b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23").expect("Valid asset id");
+    let btc_asset = confidential::Asset::Explicit(asset_id);
     let btc_value = confidential::Value::Explicit(21_000_000 * 100_000_000);
     let spk = elements::script::Builder::new().push_int(1).into_script();
 
@@ -31,7 +32,7 @@ fn main() {
 
     let res = tx.verify_tx_amt_proofs(&secp, &[txout]);
     match res {
-        Ok(_) => {}
+        Ok(()) => {}
         Err(e) => {
             panic!("{}", e);
         }
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 028baa32..5bbfee40 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,38 +1,69 @@
+######
+## DO NOT EDIT THIS FILE DIRECTLY. It is generated by generate-files.sh.
+## Edit that script instead and re-run it.
+######
 [package]
 name = "elements-fuzz"
+edition = "2021"
+rust-version = "1.74.0"
 version = "0.0.1"
-authors = ["Automatically generated"]
+authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
-edition = "2018"
 
 [package.metadata]
 cargo-fuzz = true
 
-[features]
-afl_fuzz = ["afl"]
-honggfuzz_fuzz = ["honggfuzz"]
-
 [dependencies]
-honggfuzz = { version = "0.5", optional = true, default-features = false }
-afl = { version = "0.11", optional = true }
-elements = { path = "..", features = ["fuzztarget", "serde"] }
+elements = { path = "../", features = [ "serde" ] }
+libfuzzer-sys = { version = "0.4.0" }
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)'] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
 
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
+[package.metadata.rbmt.lint]
+allowed_duplicates = [
+    "bitcoin_hashes",
+    "bitcoin-internals",
+    "hex-conservative",
+    "getrandom",
+    "wasi",
+]
 
 [[bin]]
-name = "deserialize_transaction"
-path = "fuzz_targets/deserialize_transaction.rs"
+name = "decode_equiv_transaction"
+path = "fuzz_targets/decode_equiv_transaction.rs"
+test = false
+doc = false
+bench = false
 
 [[bin]]
 name = "deserialize_block"
 path = "fuzz_targets/deserialize_block.rs"
+test = false
+doc = false
+bench = false
 
 [[bin]]
 name = "deserialize_output"
 path = "fuzz_targets/deserialize_output.rs"
+test = false
+doc = false
+bench = false
 
 [[bin]]
 name = "deserialize_pset"
 path = "fuzz_targets/deserialize_pset.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "deserialize_transaction"
+path = "fuzz_targets/deserialize_transaction.rs"
+test = false
+doc = false
+bench = false
diff --git a/fuzz/README.md b/fuzz/README.md
new file mode 100644
index 00000000..001f1ef0
--- /dev/null
+++ b/fuzz/README.md
@@ -0,0 +1,161 @@
+# Fuzzing
+
+`rust-bitcoin` has fuzzing harnesses setup for use with
+`cargo-fuzz`.
+
+To run the fuzz-tests as in CI -- briefly fuzzing every target -- simply
+run
+
+```bash
+./fuzz.sh
+```
+
+in this directory.
+
+By default, `fuzz.sh` runs each target for 100 seconds. Pass
+`-max_total_time` to run for longer or shorter:
+
+```bash
+./fuzz.sh -max_total_time=300
+```
+
+## Fuzzing with weak cryptography
+
+You may wish to replace the hashing and signing code with broken crypto,
+which will be faster and enable the fuzzer to do otherwise impossible
+things such as forging signatures or finding preimages to hashes.
+
+Doing so may result in spurious bug reports since the broken crypto does
+not respect the encoding or algebraic invariants upheld by the real crypto. We
+would like to improve this, but it's a nontrivial problem -- though not
+beyond the abilities of a motivated student with a few months of time.
+Please let us know if you are interested in taking this on!
+
+Meanwhile, to use the broken crypto, simply compile (and run the fuzzing
+scripts) with
+
+```bash
+RUSTFLAGS="--cfg=hashes_fuzz --cfg=secp256k1_fuzz"
+```
+
+which will replace the hashing library with broken hashes, and the
+`secp256k1` library with broken cryptography.
+
+Needless to say, NEVER COMPILE REAL CODE WITH THESE FLAGS because if a
+fuzzer can break your crypto, so can anybody.
+
+## Long-term fuzzing
+
+To see the full list of targets, the most straightforward way is to run
+
+```bash
+cargo fuzz list
+```
+
+To run each of them for an hour, run
+
+```bash
+./cycle.sh
+```
+This script uses the `chrt` utility to try to reduce the priority of the
+jobs. If you would like to run for longer, the most straightforward way
+is to edit `cycle.sh` before starting. To run the fuzz-tests in parallel,
+you will need to implement a custom harness.
+
+To run a single fuzztest indefinitely, run
+
+```bash
+cargo +nightly fuzz run "<target>" 
+```
+
+## Adding fuzz tests
+
+All fuzz tests can be found in the `fuzz_target/` directory. Adding a new
+one is as simple as copying an existing one and editing the `do_test`
+function to do what you want.
+
+If your test clearly belongs to a specific crate, please put it in that
+crate's directory. Otherwise, you can put it directly in `fuzz_target/`.
+
+If you need to add dependencies, edit the file `generate-files.sh` to add
+it to the generated `Cargo.toml`.
+
+Once you've added a fuzztest, regenerate the `Cargo.toml` and CI job by
+running
+
+```bash
+./generate-files.sh
+```
+
+Then to test your fuzztest, run
+
+```bash
+./fuzz.sh <target>
+```
+
+If it is working, you will see a rapid stream of data for many seconds
+(you can hit Ctrl+C to stop it early) that looks something like this:
+```text
+INFO: Running with entropic power schedule (0xFF, 100).
+INFO: Seed: 2953319389
+INFO: Loaded 1 modules   (9121 inline 8-bit counters): 9121 [0x104132ea0, 0x104135241),
+INFO: Loaded 1 PC tables (9121 PCs): 9121 [0x104135248,0x104158c58),
+INFO:        0 files found in /some/path/to/rust-bitcoin/fuzz/corpus/units_arbitrary_weight
+INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
+INFO: A corpus is not provided, starting from an empty corpus
+#2	INITED cov: 42 ft: 42 corp: 1/1b exec/s: 0 rss: 36Mb
+#411	NEW    cov: 43 ft: 43 corp: 2/9b lim: 8 exec/s: 0 rss: 37Mb L: 8/8 MS: 4 ChangeBinInt-ShuffleBytes-ShuffleBytes-InsertRepeatedBytes-
+#1329	NEW    cov: 43 ft: 44 corp: 3/26b lim: 17 exec/s: 0 rss: 37Mb L: 17/17 MS: 3 InsertRepeatedBytes-CMP-CopyPart- DE: "\001\000\000\000"-
+#1357	REDUCE cov: 43 ft: 44 corp: 3/25b lim: 17 exec/s: 0 rss: 37Mb L: 16/16 MS: 3 CopyPart-CMP-EraseBytes- DE: "\000\000\000\000\000\000\000\000"-
+...
+```
+If you don't see this, you should quickly see an error.
+
+## Reproducing Failures
+
+If a fuzztest fails, it will exit with a summary which looks something like
+```text
+...
+thread '<unnamed>' (3001874) panicked at units/src/weight.rs:103:25:
+attempt to multiply with overflow
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+==66478== ERROR: libFuzzer: deadly signal
+    #0 0x0001049fd3c4 in __sanitizer_print_stack_trace+0x28 (librustc-nightly_rt.asan.dylib:arm64+0x5d3c4)
+    #1 0x000104078b90 in fuzzer::PrintStackTrace()+0x30 (units_arbitrary_weight:arm64+0x100070b90)
+    #2 0x00010406d074 in fuzzer::Fuzzer::CrashCallback()+0x54 (units_arbitrary_weight:arm64+0x100065074)
+    #3 0x000180d26740 in _sigtramp+0x34 (libsystem_platform.dylib:arm64+0x3740)
+    ...
+```
+This will tell you where the test failed and is followed by information about how to reproduce the crash.
+It will look something like this:
+
+```text
+...
+NOTE: libFuzzer has rudimentary signal handlers.
+      Combine libFuzzer with AddressSanitizer or similar for better crash reports.
+SUMMARY: libFuzzer: deadly signal
+MS: 2 ChangeByte-CopyPart-; base unit: 25058c6b0d02cd1d71a030ad61c46b7396ddcdb9
+0x5e,0x5e,0x5e,0x5e,0x5e,0x44,0x0,0x0,0x0,0x0,0x0,0x5d,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x5e,0xa,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1,0xa5,0x1,0x1,0x1,
+^^^^^D\000\000\000\000\000]\001\000\000\000\000\000\000^\012\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\001\245\001\001\001
+artifact_prefix='/some/path/to/rust-bitcoin/fuzz/artifacts/units_arbitrary_weight/'; Test unit written to /some/path/to/rust-bitcoin/fuzz/artifacts/units_arbitrary_weight/crash-1b454523d38a6c3f45d453dfea4099f3cb574822
+Base64: Xl5eXl5EAAAAAABdAQAAAAAAAF4KAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBpQEBAQ==
+────────────────────────────────────────────────────────────────────────────────
+
+Failing input:
+
+	fuzz/artifacts/units_arbitrary_weight/crash-1b454523d38a6c3f45d453dfea4099f3cb574822
+
+Output of `std::fmt::Debug`:
+
+	[94, 94, 94, 94, 94, 68, 0, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 0, 0, 94, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 165, 1, 1, 1]
+
+Reproduce with:
+
+	cargo fuzz run units_arbitrary_weight fuzz/artifacts/units_arbitrary_weight/crash-1b454523d38a6c3f45d453dfea4099f3cb574822
+
+Minimize test case with:
+
+	cargo fuzz tmin units_arbitrary_weight fuzz/artifacts/units_arbitrary_weight/crash-1b454523d38a6c3f45d453dfea4099f3cb574822
+
+────────────────────────────────────────────────────────────────────────────────
+```
diff --git a/fuzz/cycle.sh b/fuzz/cycle.sh
new file mode 100755
index 00000000..84c1cb6a
--- /dev/null
+++ b/fuzz/cycle.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# Continuously cycle over fuzz targets running each for 1 hour.
+# It uses chrt SCHED_IDLE so that other process takes priority.
+#
+# For cargo-fuzz usage see https://github.com/rust-fuzz/cargo-fuzz?tab=readme-ov-file#usage
+
+set -euo pipefail
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+# can't find the file because of the ENV var
+# shellcheck source=/dev/null
+source "$REPO_DIR/fuzz/fuzz-util.sh"
+
+while :
+do
+  for targetFile in $(listTargetFiles); do
+    targetName=$(targetFileToName "$targetFile")
+    echo "Fuzzing target $targetName ($targetFile)"
+
+    # fuzz for one hour
+    chrt -i 0 cargo +nightly fuzz run "$targetName" -- -max_total_time=3600
+    cargo +nightly fuzz cmin "$targetName" 
+  done
+done
+
diff --git a/fuzz/fuzz-util.sh b/fuzz/fuzz-util.sh
new file mode 100755
index 00000000..5b63de9c
--- /dev/null
+++ b/fuzz/fuzz-util.sh
@@ -0,0 +1,45 @@
+#!/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() {
+  pushd "$REPO_DIR/fuzz" > /dev/null || exit 1
+  find fuzz_targets/ -type f -name "*.rs" | sort
+  popd > /dev/null || exit 1
+}
+
+targetFileToName() {
+  echo "$1" \
+    | sed 's/^fuzz_targets\///' \
+    | sed 's/\.rs$//' \
+    | sed 's/\//_/g' \
+    | sed 's/^_//g'
+}
+
+# Utility function to avoid CI failures on Windows
+checkWindowsFiles() {
+  incorrectFilenames=$(find . -type f -name "*,*" -o -name "*:*" -o -name "*<*" -o -name "*>*" -o -name "*|*" -o -name "*\?*" -o -name "*\**" -o -name "*\"*" | wc -l)
+  if [ "$incorrectFilenames" -gt 0 ]; then
+    echo "Bailing early because there is a Windows-incompatible filename in the tree."
+    exit 2
+  fi
+}
+
+# Checks whether a fuzz case has artifacts, and dumps them in hex
+checkReport() {
+  artifactDir="fuzz/artifacts/$1"
+  if [ -d "$artifactDir" ] && [ -n "$(ls -A "$artifactDir" 2>/dev/null)" ]; then
+    echo "Artifacts found for target: $1"
+    for artifact in "$artifactDir"/*; do
+      if [ -f "$artifact" ]; then
+        echo "Artifact: $(basename "$artifact")"
+        xxd -p -c10000 < "$artifact"
+      fi
+    done
+    exit 1
+  fi
+}
diff --git a/fuzz/fuzz.sh b/fuzz/fuzz.sh
new file mode 100755
index 00000000..3a4aa602
--- /dev/null
+++ b/fuzz/fuzz.sh
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# This script is used to briefly fuzz every target when no target is provided. Otherwise, it will briefly fuzz the
+# provided target
+
+set -euox pipefail
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# can't find the file because of the ENV var
+# shellcheck source=/dev/null
+source "$REPO_DIR/fuzz/fuzz-util.sh"
+
+target=
+max_total_time=100
+
+for arg in "$@"; do
+  case "$arg" in
+    -max_total_time=*)
+      max_total_time="${arg#-max_total_time=}"
+      ;;
+    -*)
+      echo "Unknown option: $arg"
+      exit 2
+      ;;
+    *)
+      if [ -n "$target" ]; then
+        echo "Unexpected argument: $arg"
+        exit 2
+      fi
+      target="$arg"
+      ;;
+  esac
+done
+
+case "$max_total_time" in
+  ''|*[!0-9]*)
+    echo "-max_total_time must be a non-negative integer number of seconds"
+    exit 2
+    ;;
+esac
+
+# Check that input files are correct Windows file names
+checkWindowsFiles
+
+if [ -z "$target" ]; then
+  targetFiles="$(listTargetFiles)"
+else
+  targetFiles=fuzz_targets/"$target".rs
+fi
+
+cargo --version
+rustc --version
+
+# Testing
+cargo install --force --locked --version 0.12.0 cargo-fuzz
+for targetFile in $targetFiles; do
+  targetName=$(targetFileToName "$targetFile")
+  echo "Fuzzing target $targetName ($targetFile) for $max_total_time seconds"
+  # cargo-fuzz will check for the corpus at fuzz/corpus/<target>
+  cargo +nightly fuzz run "$targetName" -- -max_total_time="$max_total_time"
+  checkReport "$targetName"
+done
diff --git a/fuzz/fuzz_targets/decode_equiv_transaction.rs b/fuzz/fuzz_targets/decode_equiv_transaction.rs
new file mode 100644
index 00000000..38281db5
--- /dev/null
+++ b/fuzz/fuzz_targets/decode_equiv_transaction.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Fuzz test for equivalent decoding between the legacy and consensus-encoding decoding schemes.
+
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
+use libfuzzer_sys::fuzz_target;
+
+use elements::bitcoin::hex::DisplayHex as _;
+
+type Target = elements::Transaction;
+
+#[cfg(not(fuzzing))]
+fn main() {}
+
+struct DisplayError<'e>(&'e dyn std::error::Error);
+
+impl core::fmt::Display for DisplayError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}", self.0)?;
+        let mut e = self.0;
+        while let Some(source) = e.source() {
+            writeln!(f, "caused by {}", source)?;
+            e = source;
+        }
+        Ok(())
+    }
+}
+
+fn do_test(data: &[u8]) {
+    let old: Result<Target, _> = elements::encode::deserialize(data);
+    let new: Result<Target, _> = elements::encoding::decode_from_slice(data);
+
+    match (old, new) {
+        (Err(_), Err(_)) => {},
+        (Err(e), Ok(new)) => {
+            let e = DisplayError(&e);
+            panic!("Decodable trait failed with {e}; Decode parsed {:?}", new);
+        }
+        (Ok(old), Err(e)) => {
+            let e = DisplayError(&e);
+            panic!("Decode trait failed with {e}; Decodable parsed {:?}", old);
+        }
+        (Ok(old), Ok(new)) => {
+            assert_eq!(
+                old, new,
+                "Decodable (left) did not match Decode (right)",
+            );
+
+            let reser_old = elements::encode::serialize(&old);
+            let reser_new = elements::encoding::encode_to_vec(&new);
+            assert_eq!(
+                reser_old, reser_new,
+                "Encodable (left) did not match Encode (right)\nOld hex: {}\nNew hex: {}\nTransaction: {:?}",
+                reser_old.as_hex(),
+                reser_new.as_hex(),
+                old,
+            );
+        }
+    }
+}
+
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn duplicate_crash() {
+        let v = elements::hex::decode_to_vec("abcd").unwrap();
+        super::do_test(&v);
+    }
+}
diff --git a/fuzz/fuzz_targets/deserialize_block.rs b/fuzz/fuzz_targets/deserialize_block.rs
index 061fec7e..f93a478b 100644
--- a/fuzz/fuzz_targets/deserialize_block.rs
+++ b/fuzz/fuzz_targets/deserialize_block.rs
@@ -1,5 +1,10 @@
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
 
-extern crate elements;
+use libfuzzer_sys::fuzz_target;
+
+#[cfg(not(fuzzing))]
+fn main() {}
 
 fn do_test(data: &[u8]) {
     let block_result: Result<elements::Block, _> = elements::encode::deserialize(data);
@@ -12,25 +17,9 @@ fn do_test(data: &[u8]) {
     }
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
 
 #[cfg(test)]
 mod tests {
@@ -39,9 +28,9 @@ mod tests {
         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',
+                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 {
diff --git a/fuzz/fuzz_targets/deserialize_output.rs b/fuzz/fuzz_targets/deserialize_output.rs
index 22bc06d9..25255340 100644
--- a/fuzz/fuzz_targets/deserialize_output.rs
+++ b/fuzz/fuzz_targets/deserialize_output.rs
@@ -1,5 +1,10 @@
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
 
-extern crate elements;
+use libfuzzer_sys::fuzz_target;
+
+#[cfg(not(fuzzing))]
+fn main() {}
 
 fn do_test(data: &[u8]) {
     let result: Result<elements::TxOut, _> = elements::encode::deserialize(data);
@@ -18,25 +23,9 @@ fn do_test(data: &[u8]) {
     }
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
 
 #[cfg(test)]
 mod tests {
@@ -45,9 +34,9 @@ mod tests {
         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',
+                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 {
diff --git a/fuzz/fuzz_targets/deserialize_pset.rs b/fuzz/fuzz_targets/deserialize_pset.rs
index bf1576a5..e7a26237 100644
--- a/fuzz/fuzz_targets/deserialize_pset.rs
+++ b/fuzz/fuzz_targets/deserialize_pset.rs
@@ -1,5 +1,10 @@
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
 
-extern crate elements;
+use libfuzzer_sys::fuzz_target;
+
+#[cfg(not(fuzzing))]
+fn main() {}
 
 fn do_test(data: &[u8]) {
     let psbt: Result<elements::pset::PartiallySignedTransaction, _> = elements::encode::deserialize(data);
@@ -14,25 +19,9 @@ fn do_test(data: &[u8]) {
     }
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
 
 #[cfg(test)]
 mod tests {
@@ -41,9 +30,9 @@ mod tests {
         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',
+                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 {
diff --git a/fuzz/fuzz_targets/deserialize_transaction.rs b/fuzz/fuzz_targets/deserialize_transaction.rs
index 25148086..288c627d 100644
--- a/fuzz/fuzz_targets/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/deserialize_transaction.rs
@@ -1,5 +1,10 @@
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
 
-extern crate elements;
+use libfuzzer_sys::fuzz_target;
+
+#[cfg(not(fuzzing))]
+fn main() {}
 
 fn do_test(data: &[u8]) {
     let tx_result: Result<elements::Transaction, _> = elements::encode::deserialize(data);
@@ -9,14 +14,14 @@ fn do_test(data: &[u8]) {
             let reser = elements::encode::serialize(&tx);
             assert_eq!(data, &reser[..]);
             let len = reser.len();
-            let calculated_weight = tx.get_weight();
+            let calculated_weight = tx.weight();
             for input in &mut tx.input {
                 input.witness = elements::TxInWitness::default();
             }
             for output in &mut tx.output {
                 output.witness = elements::TxOutWitness::default();
             }
-            assert_eq!(tx.has_witness(), false);
+            assert!(!tx.has_witness());
             let no_witness_len = elements::encode::serialize(&tx).len();
             assert_eq!(no_witness_len * 3 + len, calculated_weight);
 
@@ -31,25 +36,9 @@ fn do_test(data: &[u8]) {
     }
 }
 
-#[cfg(feature = "afl")]
-extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    afl::read_stdio_bytes(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
 
 #[cfg(test)]
 mod tests {
@@ -58,9 +47,9 @@ mod tests {
         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',
+                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 {
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
new file mode 100755
index 00000000..dc19fb28
--- /dev/null
+++ b/fuzz/generate-files.sh
@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# can't find the file because of the ENV var
+# shellcheck source=/dev/null
+source "$REPO_DIR/fuzz/fuzz-util.sh"
+
+# 1. Generate fuzz/Cargo.toml
+cat > "$REPO_DIR/fuzz/Cargo.toml" <<EOF
+######
+## DO NOT EDIT THIS FILE DIRECTLY. It is generated by generate-files.sh.
+## Edit that script instead and re-run it.
+######
+[package]
+name = "elements-fuzz"
+edition = "2021"
+rust-version = "1.74.0"
+version = "0.0.1"
+authors = ["Generated by fuzz/generate-files.sh"]
+publish = false
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+elements = { path = "../", features = [ "serde" ] }
+libfuzzer-sys = { version = "0.4.0" }
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)'] }
+
+[lints.clippy]
+redundant_clone = "warn"
+use_self = "warn"
+
+[package.metadata.rbmt.lint]
+allowed_duplicates = [
+    "bitcoin_hashes",
+    "bitcoin-internals",
+    "hex-conservative",
+    "getrandom",
+    "wasi",
+]
+EOF
+
+for targetFile in $(listTargetFiles); do
+    targetName=$(targetFileToName "$targetFile")
+    cat >> "$REPO_DIR/fuzz/Cargo.toml" <<EOF
+
+[[bin]]
+name = "$targetName"
+path = "$targetFile"
+test = false
+doc = false
+bench = false
+EOF
+done
+
+# 2. Generate .github/workflows/cron-daily-fuzz.yml
+cat > "$REPO_DIR/.github/workflows/cron-daily-fuzz.yml" <<EOF
+######
+## DO NOT EDIT THIS FILE DIRECTLY. It is generated by generate-files.sh.
+## Edit that script instead and re-run it.
+######
+name: Fuzz
+on:
+  schedule:
+    # 5am every day UTC, this correlates to:
+    # - 10pm PDT
+    # - 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:
+        fuzz_target: [
+$(for name in $(cargo fuzz list); 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@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        id: cache-fuzz
+        with:
+          path: |
+            ~/.cargo/bin
+            fuzz/target
+            target
+          key: cache-\${{ matrix.target }}-\${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@5d458579430fc14a04a08a1e7d3694f545e91ce6 # stable
+        with:
+          toolchain: '1.74.0'
+      - name: fuzz
+        run: |
+          echo "Using RUSTFLAGS \$RUSTFLAGS"
+          cd fuzz && ./fuzz.sh "\${{ matrix.fuzz_target }}"
+      - run: echo "\${{ matrix.fuzz_target }}" >executed_\${{ matrix.fuzz_target }}
+      - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: executed_\${{ matrix.fuzz_target }}
+          path: executed_\${{ matrix.fuzz_target }}
+
+  verify-execution:
+    if: \${{ !github.event.act }}
+    needs: fuzz
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+      - run: cargo install --locked --version 0.12.0 cargo-fuzz
+      - name: Display structure of downloaded files
+        run: ls -R
+      - run: find executed_* -type f -exec cat {} + | sort > executed
+      - run: cargo fuzz list | sort | diff - executed
+EOF
+
diff --git a/fuzz/travis-fuzz.sh b/fuzz/travis-fuzz.sh
deleted file mode 100755
index 1b099884..00000000
--- a/fuzz/travis-fuzz.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-set -e
-cargo install --force honggfuzz --no-default-features
-for TARGET in fuzz_targets/*; do
-    FILENAME=$(basename $TARGET)
-	FILE="${FILENAME%.*}"
-	if [ -d hfuzz_input/$FILE ]; then
-	    HFUZZ_INPUT_ARGS="-f hfuzz_input/$FILE/input"
-	fi
-	HFUZZ_BUILD_ARGS="--features honggfuzz_fuzz" HFUZZ_RUN_ARGS="-N100000 --exit_upon_crash -v $HFUZZ_INPUT_ARGS" cargo hfuzz run $FILE
-
-	if [ -f hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT ]; then
-		cat hfuzz_workspace/$FILE/HONGGFUZZ.REPORT.TXT
-		for CASE in hfuzz_workspace/$FILE/SIG*; do
-			cat $CASE | xxd -p
-		done
-		exit 1
-	fi
-done
diff --git a/rbmt-version b/rbmt-version
new file mode 100644
index 00000000..de57ca2d
--- /dev/null
+++ b/rbmt-version
@@ -0,0 +1 @@
+6560b728ae6a81af9d92713b630ba26772fbd970
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000..e9b78f17
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,84 @@
+ignore = [
+    "/",
+    "!/src/lib.rs",
+    "!/src/confidential/*.rs",
+    "!/src/transaction/decoders.rs",
+    "!/src/transaction/encoders.rs",
+    "!/src/transaction/pegin_witness.rs"
+]
+hard_tabs = false
+tab_spaces = 4
+newline_style = "Auto"
+indent_style = "Block"
+
+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`.
+# fn_call_width = 60
+# attr_fn_like_width = 70
+# struct_lit_width = 18
+# struct_variant_width = 35
+# array_width = 60
+# chain_width = 60
+# single_line_if_else_max_width = 50
+
+wrap_comments = false
+format_code_in_doc_comments = false
+comment_width = 100             # Default 80
+normalize_comments = false
+normalize_doc_attributes = false
+format_strings = false
+format_macro_matchers = false
+format_macro_bodies = true
+hex_literal_case = "Preserve"
+empty_item_single_line = true
+struct_lit_single_line = true
+fn_single_line = true           # Default false
+where_single_line = false
+imports_indent = "Block"
+imports_layout = "Mixed"
+imports_granularity = "Module"     # Default "Preserve"
+group_imports = "StdExternalCrate" # Default "Preserve"
+reorder_imports = true
+reorder_modules = true
+reorder_impl_items = false
+type_punctuation_density = "Wide"
+space_before_colon = false
+space_after_colon = true
+spaces_around_ranges = false
+binop_separator = "Front"
+remove_nested_parens = true
+combine_control_expr = true
+overflow_delimited_expr = false
+struct_field_align_threshold = 0
+enum_discrim_align_threshold = 0
+match_arm_blocks = false        # Default true
+match_arm_leading_pipes = "Never"
+force_multiline_blocks = false
+fn_params_layout = "Tall"
+brace_style = "SameLineWhere"
+control_brace_style = "AlwaysSameLine"
+trailing_semicolon = true
+trailing_comma = "Vertical"
+match_block_trailing_comma = false
+blank_lines_upper_bound = 1
+blank_lines_lower_bound = 0
+edition = "2021"
+style_edition = "2021"
+inline_attribute_width = 0
+format_generated_files = true
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true
+condense_wildcard_suffixes = false
+color = "Auto"
+unstable_features = false
+disable_all_formatting = false
+skip_children = false
+show_parse_errors = true
+error_on_line_overflow = false
+error_on_unformatted = false
+emit_mode = "Files"
+make_backup = false
diff --git a/src/address.rs b/src/address.rs
index d6c2c17d..55ea613c 100644
--- a/src/address.rs
+++ b/src/address.rs
@@ -15,27 +15,30 @@
 //! # Addresses
 //!
 
+use std::convert::{TryFrom as _, TryInto as _};
 use std::error;
 use std::fmt;
+use std::fmt::Write as _;
 use std::str::FromStr;
 
-use bitcoin::bech32::{self, u5, FromBase32, ToBase32};
-use bitcoin::util::base58;
+use bech32::{Bech32, Bech32m, ByteIterExt, Fe32, Fe32IterExt, Hrp};
+use crate::blech32::{Blech32, Blech32m};
+use bitcoin::base58;
+use bitcoin::hashes::Hash as _;
 use bitcoin::PublicKey;
-use bitcoin::hashes::Hash;
+use internals::array::ArrayExt as _;
+use internals::slice::SliceExt;
 use secp256k1_zkp;
 use secp256k1_zkp::Secp256k1;
 use secp256k1_zkp::Verification;
 #[cfg(feature = "serde")]
 use serde;
 
-use crate::blech32;
-
 use crate::schnorr::{TapTweak, TweakedPublicKey, UntweakedPublicKey};
-use crate::taproot::TapBranchHash;
+use crate::taproot::TapNodeHash;
 
-use crate::{PubkeyHash, ScriptHash, WPubkeyHash, WScriptHash};
 use crate::{opcodes, script};
+use crate::{PubkeyHash, ScriptHash, WScriptHash};
 
 /// Encoding error
 #[derive(Debug, PartialEq)]
@@ -43,9 +46,9 @@ pub enum AddressError {
     /// Base58 encoding error
     Base58(base58::Error),
     /// Bech32 encoding error
-    Bech32(bech32::Error),
+    Bech32(bech32::primitives::decode::SegwitHrpstringError),
     /// Blech32 encoding error
-    Blech32(bech32::Error),
+    Blech32(crate::blech32::decode::SegwitHrpstringError),
     /// Was unable to parse the address.
     InvalidAddress(String),
     /// Script version must be 0 to 16 inclusive
@@ -61,6 +64,24 @@ pub enum AddressError {
 
     /// An invalid blinding pubkey was encountered.
     InvalidBlindingPubKey(secp256k1_zkp::UpstreamError),
+
+    /// The length (in bytes) of the object was not correct.
+    InvalidLength(usize),
+
+    /// Address version byte were not recognized.
+    InvalidAddressVersion(u8),
+}
+
+impl From<bech32::primitives::decode::SegwitHrpstringError> for AddressError {
+    fn from(e: bech32::primitives::decode::SegwitHrpstringError) -> Self {
+        AddressError::Bech32(e)
+    }
+}
+
+impl From<crate::blech32::decode::SegwitHrpstringError> for AddressError {
+    fn from(e: crate::blech32::decode::SegwitHrpstringError) -> Self {
+        AddressError::Blech32(e)
+    }
 }
 
 impl fmt::Display for AddressError {
@@ -76,10 +97,18 @@ impl fmt::Display for AddressError {
                 write!(f, "invalid witness script version: {}", wver)
             }
             AddressError::InvalidWitnessProgramLength(ref len) => {
-                write!(f, "the witness program must be between 2 and 40 bytes in length, not {}", len)
+                write!(
+                    f,
+                    "the witness program must be between 2 and 40 bytes in length, not {}",
+                    len
+                )
             }
             AddressError::InvalidSegwitV0ProgramLength(ref len) => {
-                write!(f, "a v0 witness program must be length 20 or 32, not {}", len)
+                write!(
+                    f,
+                    "a v0 witness program must be length 20 or 32, not {}",
+                    len
+                )
             }
             AddressError::InvalidBlindingPubKey(ref e) => {
                 write!(f, "an invalid blinding pubkey was encountered: {}", e)
@@ -90,6 +119,12 @@ impl fmt::Display for AddressError {
             AddressError::InvalidSegwitV0Encoding => {
                 write!(f, "v0 witness program must use b(l)ech32 not b(l)ech32m")
             }
+            AddressError::InvalidLength(len) => {
+                write!(f, "Address data has invalid length {}", len)
+            }
+            AddressError::InvalidAddressVersion(v) => {
+                write!(f, "address version {} is invalid for this type", v)
+            }
         }
     }
 }
@@ -123,9 +158,9 @@ pub struct AddressParams {
     /// The base58 prefix for blinded addresses.
     pub blinded_prefix: u8,
     /// The bech32 HRP for unblinded segwit addresses.
-    pub bech_hrp: &'static str,
+    pub bech_hrp: Hrp,
     /// The bech32 HRP for blinded segwit addresses.
-    pub blech_hrp: &'static str,
+    pub blech_hrp: Hrp,
 }
 
 impl AddressParams {
@@ -134,8 +169,8 @@ impl AddressParams {
         p2pkh_prefix: 57,
         p2sh_prefix: 39,
         blinded_prefix: 12,
-        bech_hrp: "ex",
-        blech_hrp: "lq",
+        bech_hrp: Hrp::parse_unchecked("ex"),
+        blech_hrp: Hrp::parse_unchecked("lq"),
     };
 
     /// The default Elements network address parameters.
@@ -143,8 +178,8 @@ impl AddressParams {
         p2pkh_prefix: 235,
         p2sh_prefix: 75,
         blinded_prefix: 4,
-        bech_hrp: "ert",
-        blech_hrp: "el",
+        bech_hrp: Hrp::parse_unchecked("ert"),
+        blech_hrp: Hrp::parse_unchecked("el"),
     };
 
     /// The default liquid testnet network address parameters.
@@ -152,13 +187,13 @@ impl AddressParams {
         p2pkh_prefix: 36,
         p2sh_prefix: 19,
         blinded_prefix: 23,
-        bech_hrp: "tex",
-        blech_hrp: "tlq",
+        bech_hrp: Hrp::parse_unchecked("tex"),
+        blech_hrp: Hrp::parse_unchecked("tlq"),
     };
 }
 
 /// The method used to produce an address
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Payload {
     /// pay-to-pkhash address
     PubkeyHash(PubkeyHash),
@@ -167,14 +202,14 @@ pub enum Payload {
     /// Segwit address
     WitnessProgram {
         /// The segwit version.
-        version: u5,
+        version: Fe32,
         /// The segwit program.
         program: Vec<u8>,
     },
 }
 
 /// An Elements address.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct Address {
     /// the network
     pub params: &'static AddressParams,
@@ -190,6 +225,11 @@ impl Address {
         self.blinding_pubkey.is_some()
     }
 
+    /// Return if the address is for the Liquid network
+    pub fn is_liquid(&self) -> bool {
+        self.params == &AddressParams::LIQUID
+    }
+
     /// Creates a pay to (compressed) public key hash address from a public key
     /// This is the preferred non-witness type address
     #[inline]
@@ -198,12 +238,9 @@ impl Address {
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
-        let mut hash_engine = PubkeyHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
-
         Address {
             params,
-            payload: Payload::PubkeyHash(PubkeyHash::from_engine(hash_engine)),
+            payload: Payload::PubkeyHash(pk.pubkey_hash()),
             blinding_pubkey: blinder,
         }
     }
@@ -218,26 +255,27 @@ impl Address {
     ) -> Address {
         Address {
             params,
-            payload: Payload::ScriptHash(ScriptHash::hash(&script[..])),
+            payload: Payload::ScriptHash(ScriptHash::hash_script(script)),
             blinding_pubkey: blinder,
         }
     }
 
     /// Create a witness pay to public key address from a public key
     /// This is the native segwit address type for an output redeemable with a single signature
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided public key is not compressed.
     pub fn p2wpkh(
         pk: &PublicKey,
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
-        let mut hash_engine = WPubkeyHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
-
         Address {
             params,
             payload: Payload::WitnessProgram {
-                version: u5::try_from_u8(0).expect("0<32"),
-                program: WPubkeyHash::from_engine(hash_engine)[..].to_vec(),
+                version: Fe32::Q,
+                program: pk.wpubkey_hash().expect("public key must be compressed").as_byte_array().to_vec(),
             },
             blinding_pubkey: blinder,
         }
@@ -245,21 +283,23 @@ impl Address {
 
     /// Create a pay to script address that embeds a witness pay to public key
     /// This is a segwit address type that looks familiar (as p2sh) to legacy clients
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided public key is not compressed.
     pub fn p2shwpkh(
         pk: &PublicKey,
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
-        let mut hash_engine = ScriptHash::engine();
-        pk.write_into(&mut hash_engine).expect("engines don't error");
-
+        let pkh = pk.wpubkey_hash().expect("public key must be compressed");
         let builder = script::Builder::new()
             .push_int(0)
-            .push_slice(&ScriptHash::from_engine(hash_engine)[..]);
+            .push_slice(pkh.as_ref());
 
         Address {
             params,
-            payload: Payload::ScriptHash(ScriptHash::hash(builder.into_script().as_bytes())),
+            payload: Payload::ScriptHash(ScriptHash::hash_script(&builder.into_script())),
             blinding_pubkey: blinder,
         }
     }
@@ -273,8 +313,8 @@ impl Address {
         Address {
             params,
             payload: Payload::WitnessProgram {
-                version: u5::try_from_u8(0).expect("0<32"),
-                program: WScriptHash::hash(&script[..])[..].to_vec(),
+                version: Fe32::Q,
+                program: WScriptHash::hash_script(script).as_byte_array().to_vec(),
             },
             blinding_pubkey: blinder,
         }
@@ -289,12 +329,12 @@ impl Address {
     ) -> Address {
         let ws = script::Builder::new()
             .push_int(0)
-            .push_slice(&WScriptHash::hash(&script[..])[..])
+            .push_slice(WScriptHash::hash_script(script).as_ref())
             .into_script();
 
         Address {
             params,
-            payload: Payload::ScriptHash(ScriptHash::hash(&ws[..])),
+            payload: Payload::ScriptHash(ScriptHash::hash_script(&ws)),
             blinding_pubkey: blinder,
         }
     }
@@ -303,7 +343,7 @@ impl Address {
     pub fn p2tr<C: Verification>(
         secp: &Secp256k1<C>,
         internal_key: UntweakedPublicKey,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
         blinder: Option<secp256k1_zkp::PublicKey>,
         params: &'static AddressParams,
     ) -> Address {
@@ -312,7 +352,7 @@ impl Address {
             payload: {
                 let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);
                 Payload::WitnessProgram {
-                    version: u5::try_from_u8(1).expect("0<32"),
+                    version: Fe32::P,
                     program: output_key.into_inner().serialize().to_vec(),
                 }
             },
@@ -331,7 +371,7 @@ impl Address {
         Address {
             params,
             payload: Payload::WitnessProgram {
-                version: u5::try_from_u8(1).expect("0<32"),
+                version: Fe32::P,
                 program: output_key.into_inner().serialize().to_vec(),
             },
             blinding_pubkey: blinder,
@@ -346,22 +386,22 @@ impl Address {
     ) -> Option<Address> {
         Some(Address {
             payload: if script.is_p2pkh() {
-                Payload::PubkeyHash(Hash::from_slice(&script.as_bytes()[3..23]).unwrap())
+                Payload::PubkeyHash(PubkeyHash::from_byte_array(script.as_bytes()[3..23].try_into().unwrap()))
             } else if script.is_p2sh() {
-                Payload::ScriptHash(Hash::from_slice(&script.as_bytes()[2..22]).unwrap())
+                Payload::ScriptHash(ScriptHash::from_byte_array(script.as_bytes()[2..22].try_into().unwrap()))
             } else if script.is_v0_p2wpkh() {
                 Payload::WitnessProgram {
-                    version: u5::try_from_u8(0).expect("0<32"),
+                    version: Fe32::Q,
                     program: script.as_bytes()[2..22].to_vec(),
                 }
             } else if script.is_v0_p2wsh() {
                 Payload::WitnessProgram {
-                    version: u5::try_from_u8(0).expect("0<32"),
+                    version: Fe32::Q,
                     program: script.as_bytes()[2..34].to_vec(),
                 }
             } else if script.is_v1plus_p2witprog() {
                 Payload::WitnessProgram {
-                    version: u5::try_from_u8(script.as_bytes()[0] - 0x50).expect("0<32"),
+                    version: Fe32::try_from(script.as_bytes()[0] - 0x50).expect("0<32"),
                     program: script.as_bytes()[2..].to_vec(),
                 }
             } else {
@@ -378,22 +418,25 @@ impl Address {
             Payload::PubkeyHash(ref hash) => script::Builder::new()
                 .push_opcode(opcodes::all::OP_DUP)
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash[..])
+                .push_slice(hash.as_ref())
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_CHECKSIG),
             Payload::ScriptHash(ref hash) => script::Builder::new()
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash[..])
+                .push_slice(hash.as_byte_array())
                 .push_opcode(opcodes::all::OP_EQUAL),
             Payload::WitnessProgram {
                 version: witver,
                 program: ref witprog,
-            } => script::Builder::new().push_int(witver.to_u8() as i64).push_slice(&witprog),
+            } => script::Builder::new()
+                .push_int(i64::from(witver.to_u8()))
+                .push_slice(witprog),
         }
         .into_script()
     }
 
     /// Convert this address to an unconfidential address.
+    #[must_use]
     pub fn to_unconfidential(&self) -> Address {
         Address {
             params: self.params,
@@ -403,6 +446,7 @@ impl Address {
     }
 
     /// Convert this address to a confidential address with the given blinding pubkey.
+    #[must_use]
     pub fn to_confidential(&self, blinding_pubkey: secp256k1_zkp::PublicKey) -> Address {
         Address {
             params: self.params,
@@ -416,113 +460,71 @@ impl Address {
         blinded: bool,
         params: &'static AddressParams,
     ) -> Result<Address, AddressError> {
-        let (payload, is_bech32m) = if !blinded {
-            let (_, payload, variant) = bech32::decode(s).map_err(AddressError::Bech32)?;
-            (payload, variant == bech32::Variant::Bech32m)
+        let (version, data): (Fe32, Vec<u8>) = if blinded {
+            let hs = crate::blech32::decode::SegwitHrpstring::new(s)?;
+            (hs.witness_version(), hs.byte_iter().collect())
         } else {
-            let (_, payload, variant) = blech32::decode(s).map_err(AddressError::Blech32)?;
-            (payload, variant == blech32::Variant::Blech32m)
-        };
-
-        if payload.is_empty() {
-            return Err(AddressError::InvalidAddress(s.to_owned()));
-        }
-
-        // Get the script version and program (converted from 5-bit to 8-bit)
-        let (version, data) = {
-            let (v, p5) = payload.split_at(1);
-            let data_res = Vec::from_base32(p5);
-            if let Err(e) = data_res {
-                return Err(match blinded {
-                    true => AddressError::Blech32(e),
-                    false => AddressError::Bech32(e),
-                });
-            }
-            (v[0], data_res.unwrap())
+            let hs = bech32::primitives::decode::SegwitHrpstring::new(s)?;
+            (hs.witness_version(), hs.byte_iter().collect())
         };
 
-        // Generic segwit checks.
-        if version.to_u8() > 16 {
-            return Err(AddressError::InvalidWitnessVersion(version.to_u8()));
-        }
-        if data.len() < 2 || data.len() > 40 + if blinded { 33 } else { 0 } {
-            return Err(AddressError::InvalidWitnessProgramLength(data.len() - if blinded { 33 } else { 0 }));
-        }
-
-        // Specific segwit v0 check.
-        if !blinded && version.to_u8() == 0 && data.len() != 20 && data.len() != 32 {
-            return Err(AddressError::InvalidSegwitV0ProgramLength(data.len()));
-        }
-        if blinded && version.to_u8() == 0 && data.len() != 53 && data.len() != 65 {
-            return Err(AddressError::InvalidSegwitV0ProgramLength(data.len() - 33));
-        }
-
-        if version.to_u8() == 0 && is_bech32m {
-            return Err(AddressError::InvalidSegwitV0Encoding);
-        } else if version.to_u8() > 0 && !is_bech32m {
-            return Err(AddressError::InvalidWitnessEncoding);
-        }
-
         let (blinding_pubkey, program) = match blinded {
-            true => (
+            true => {
+                let (pk, rest) = SliceExt::split_first_chunk::<33>(data.as_slice())
+                    .ok_or(AddressError::InvalidSegwitV0Encoding)?;
+                (
                 Some(
-                    secp256k1_zkp::PublicKey::from_slice(&data[..33])
+                    secp256k1_zkp::PublicKey::from_slice(pk)
                         .map_err(AddressError::InvalidBlindingPubKey)?,
-                ),
-                data[33..].to_vec(),
-            ),
+                    ),
+                    rest.to_vec(),
+                )
+            },
             false => (None, data),
         };
 
         Ok(Address {
             params,
-            payload: Payload::WitnessProgram {
-                version,
-                program,
-            },
+            payload: Payload::WitnessProgram { version, program },
             blinding_pubkey,
         })
     }
 
     // data.len() should be >= 1 when this method is called
     fn from_base58(data: &[u8], params: &'static AddressParams) -> Result<Address, AddressError> {
+        let len_error = AddressError::InvalidLength(data.len());
         // When unblinded, the structure is:
         // <1: regular prefix> <20: hash160>
         // When blinded, the structure is:
         // <1: blinding prefix> <1: regular prefix> <33: blinding pubkey> <20: hash160>
 
-        let (blinded, prefix) = match data[0] == params.blinded_prefix {
-            true => {
-                if data.len() != 55 {
-                    return Err(base58::Error::InvalidLength(data.len()).into());
-                }
-                (true, data[1])
-            }
-            false => {
-                if data.len() != 21 {
-                    return Err(base58::Error::InvalidLength(data.len()).into());
-                }
-                (false, data[0])
-            }
+        let Some((blinding_prefix, blinded_data)) = data.split_first() else {
+            return Err(len_error);
         };
 
-        let (blinding_pubkey, payload_data) = match blinded {
-            true => (
-                Some(
-                    secp256k1_zkp::PublicKey::from_slice(&data[2..35])
-                        .map_err(AddressError::InvalidBlindingPubKey)?,
-                ),
-                &data[35..],
-            ),
-            false => (None, &data[1..]),
+        let (prefix, blinding_pubkey, hash) = if *blinding_prefix == params.blinded_prefix {
+            let Some((prefix, pubkey_and_hash)) = blinded_data.split_first() else {
+                return Err(len_error);
+            };
+
+            let pubkey_and_hash = <&[u8; 53]>::try_from(pubkey_and_hash).map_err(|_| len_error)?;
+            let (pubkey, hash) = pubkey_and_hash.split_array::<33, 20>();
+
+            let blinding_pubkey = secp256k1_zkp::PublicKey::from_slice(pubkey)
+                .map_err(AddressError::InvalidBlindingPubKey)?;
+
+            (prefix, Some(blinding_pubkey), hash)
+        } else {
+            let hash = <&[u8; 20]>::try_from(blinded_data).map_err(|_| len_error)?;
+            (blinding_prefix, None, hash)
         };
 
-        let payload = if prefix == params.p2pkh_prefix {
-            Payload::PubkeyHash(PubkeyHash::from_slice(payload_data).unwrap())
-        } else if prefix == params.p2sh_prefix {
-            Payload::ScriptHash(ScriptHash::from_slice(payload_data).unwrap())
+        let payload = if *prefix == params.p2pkh_prefix {
+            Payload::PubkeyHash(PubkeyHash::from_byte_array(*hash))
+        } else if *prefix == params.p2sh_prefix {
+            Payload::ScriptHash(ScriptHash::from_byte_array(*hash))
         } else {
-            return Err(base58::Error::InvalidAddressVersion(prefix).into());
+            return Err(AddressError::InvalidAddressVersion(*prefix));
         };
 
         Ok(Address {
@@ -533,7 +535,7 @@ impl Address {
     }
 
     /// Parse the address using the given parameters.
-    /// When using the built-in parameters, you can use [FromStr].
+    /// When using the built-in parameters, you can use [`FromStr`].
     pub fn parse_with_params(
         s: &str,
         params: &'static AddressParams,
@@ -548,9 +550,9 @@ impl Address {
 
         // Base58.
         if s.len() > 150 {
-            return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            return Err(AddressError::InvalidLength(s.len() * 11 / 15));
         }
-        let data = base58::from_check(s)?;
+        let data = base58::decode_check(s)?;
         Address::from_base58(&data, params)
     }
 }
@@ -564,13 +566,13 @@ impl fmt::Display for Address {
                     prefixed[0] = self.params.blinded_prefix;
                     prefixed[1] = self.params.p2pkh_prefix;
                     prefixed[2..35].copy_from_slice(&blinder.serialize());
-                    prefixed[35..].copy_from_slice(&hash[..]);
-                    base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
+                    prefixed[35..].copy_from_slice(hash.as_ref());
+                    base58::encode_check_to_fmt(fmt, &prefixed[..])
                 } else {
                     let mut prefixed = [0; 21];
                     prefixed[0] = self.params.p2pkh_prefix;
-                    prefixed[1..].copy_from_slice(&hash[..]);
-                    base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
+                    prefixed[1..].copy_from_slice(hash.as_ref());
+                    base58::encode_check_to_fmt(fmt, &prefixed[..])
                 }
             }
             Payload::ScriptHash(ref hash) => {
@@ -579,13 +581,13 @@ impl fmt::Display for Address {
                     prefixed[0] = self.params.blinded_prefix;
                     prefixed[1] = self.params.p2sh_prefix;
                     prefixed[2..35].copy_from_slice(&blinder.serialize());
-                    prefixed[35..].copy_from_slice(&hash[..]);
-                    base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
+                    prefixed[35..].copy_from_slice(hash.as_byte_array());
+                    base58::encode_check_to_fmt(fmt, &prefixed[..])
                 } else {
                     let mut prefixed = [0; 21];
                     prefixed[0] = self.params.p2sh_prefix;
-                    prefixed[1..].copy_from_slice(&hash[..]);
-                    base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
+                    prefixed[1..].copy_from_slice(hash.as_byte_array());
+                    base58::encode_check_to_fmt(fmt, &prefixed[..])
                 }
             }
             Payload::WitnessProgram {
@@ -597,25 +599,53 @@ impl fmt::Display for Address {
                     false => self.params.bech_hrp,
                 };
 
+                // FIXME: surely we can fix this logic to not be so repetitive.
                 if self.is_blinded() {
-                    let mut data = Vec::with_capacity(53);
                     if let Some(ref blinder) = self.blinding_pubkey {
-                        data.extend_from_slice(&blinder.serialize());
+                        let byte_iter = IntoIterator::into_iter(blinder.serialize())
+                            .chain(witprog.iter().copied());
+                        let fe_iter = byte_iter.bytes_to_fes();
+                        if witver.to_u8() == 0 {
+                            for c in fe_iter
+                                .with_checksum::<Blech32>(&hrp)
+                                .with_witness_version(witver)
+                                .chars()
+                            {
+                                fmt.write_char(c)?;
+                            }
+                        } else {
+                            for c in fe_iter
+                                .with_checksum::<Blech32m>(&hrp)
+                                .with_witness_version(witver)
+                                .chars()
+                            {
+                                fmt.write_char(c)?;
+                            }
+                        }
+                        return Ok(());
                     }
-                    data.extend_from_slice(&witprog);
-                    let mut b32_data = vec![witver];
-                    b32_data.extend_from_slice(&data.to_base32());
-                    if witver.to_u8() == 0 {
-                        blech32::encode_to_fmt(fmt, &hrp, &b32_data, blech32::Variant::Blech32)
-                    } else {
-                        blech32::encode_to_fmt(fmt, &hrp, &b32_data, blech32::Variant::Blech32m)
+                }
+
+                let byte_iter = witprog.iter().copied();
+                let fe_iter = byte_iter.bytes_to_fes();
+                if witver.to_u8() == 0 {
+                    for c in fe_iter
+                        .with_checksum::<Bech32>(&hrp)
+                        .with_witness_version(witver)
+                        .chars()
+                    {
+                        fmt.write_char(c)?;
                     }
                 } else {
-                    let var = if witver.to_u8() == 0 { bech32::Variant::Bech32 } else { bech32::Variant::Bech32m };
-                    let mut bech32_writer = bech32::Bech32Writer::new(hrp, var, fmt)?;
-                    bech32::WriteBase32::write_u5(&mut bech32_writer, witver)?;
-                    bech32::ToBase32::write_base32(&witprog, &mut bech32_writer)
+                    for c in fe_iter
+                        .with_checksum::<Bech32m>(&hrp)
+                        .with_witness_version(witver)
+                        .chars()
+                    {
+                        fmt.write_char(c)?;
+                    }
                 }
+                Ok(())
             }
         }
     }
@@ -640,15 +670,11 @@ fn find_prefix(bech32: &str) -> &str {
 /// Checks if both prefixes match, regardless of case.
 /// The first prefix can be mixed case, but the second one is expected in
 /// lower case.
-fn match_prefix(prefix_mixed: &str, prefix_lower: &str) -> bool {
-    if prefix_lower.len() != prefix_mixed.len() {
-        false
-    } else {
-        prefix_lower
-            .chars()
-            .zip(prefix_mixed.chars())
-            .all(|(char_lower, char_mixed)| char_lower == char_mixed.to_ascii_lowercase())
-    }
+fn match_prefix(prefix_mixed: &str, target: Hrp) -> bool {
+    target.len() == prefix_mixed.len() && target
+        .lowercase_char_iter()
+        .zip(prefix_mixed.chars())
+        .all(|(char_lower, char_mixed)| char_lower == char_mixed.to_ascii_lowercase())
 }
 
 impl FromStr for Address {
@@ -663,7 +689,7 @@ impl FromStr for Address {
         let net_arr = [liq, ele, liq_test];
 
         let prefix = find_prefix(s);
-        for net in net_arr.iter() {
+        for net in &net_arr {
             // Bech32.
             if match_prefix(prefix, net.bech_hrp) {
                 return Address::from_bech32(s, false, net);
@@ -675,15 +701,15 @@ impl FromStr for Address {
 
         // Base58.
         if s.len() > 150 {
-            return Err(base58::Error::InvalidLength(s.len() * 11 / 15).into());
+            return Err(AddressError::InvalidLength(s.len() * 11 / 15));
         }
-        let data = base58::from_check(s)?;
+        let data = base58::decode_check(s)?;
         if data.is_empty() {
-            return Err(base58::Error::InvalidLength(data.len()).into());
+            return Err(AddressError::InvalidLength(data.len()));
         }
 
         let p = data[0];
-        for net in net_arr.iter() {
+        for net in &net_arr {
             if p == net.p2pkh_prefix || p == net.p2sh_prefix || p == net.blinded_prefix {
                 return Address::from_base58(&data, net);
             }
@@ -749,9 +775,9 @@ impl serde::Serialize for Address {
 #[cfg(test)]
 mod test {
     use super::*;
-    use bitcoin::util::key;
-    use secp256k1_zkp::{PublicKey, Secp256k1};
     use crate::Script;
+    use bitcoin::key;
+    use secp256k1_zkp::{PublicKey, Secp256k1};
     #[cfg(feature = "serde")]
     use serde_json;
 
@@ -770,11 +796,20 @@ mod test {
         );
         #[cfg(feature = "serde")]
         assert_eq!(
-            serde_json::from_value::<Address>(serde_json::to_value(&addr).unwrap()).ok().as_ref(),
+            serde_json::from_value::<Address>(serde_json::to_value(addr).unwrap())
+                .ok()
+                .as_ref(),
             Some(addr)
         );
     }
 
+    #[test]
+    fn regression_188() {
+        // Tests that the `tlq` prefix was not accidentally changed, e.g. to `tlg` :).
+        let addr = Address::from_str("tlq1qq2xvpcvfup5j8zscjq05u2wxxjcyewk7979f3mmz5l7uw5pqmx6xf5xy50hsn6vhkm5euwt72x878eq6zxx2z58hd7zrsg9qn").unwrap();
+        roundtrips(&addr);
+    }
+
     #[test]
     fn exhaustive() {
         let blinder_hex = "0218845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166";
@@ -839,7 +874,12 @@ mod test {
 
         for &(a, blinded, ref params) in &addresses {
             let result = a.parse();
-            assert!(result.is_ok(), "vector: {}, err: \"{}\"", a, result.unwrap_err());
+            assert!(
+                result.is_ok(),
+                "vector: {}, err: \"{}\"",
+                a,
+                result.unwrap_err()
+            );
             let addr: Address = result.unwrap();
             assert_eq!(a, &addr.to_string(), "vector: {}", a);
             assert_eq!(blinded, addr.is_blinded());
@@ -857,33 +897,120 @@ mod test {
         let address: Result<Address, _> = "el1pq0umk3pez693jrrlxz9ndlkuwne93gdu9g83mhhzuyf46e3mdzfpva0w48gqgzgrklncnm0k5zeyw8my2ypfsxguu9nrdg2pc".parse();
         assert_eq!(
             address.err().unwrap().to_string(),
-            "v1+ witness program must use b(l)ech32m not b(l)ech32",
+            "blech32 error: invalid checksum", // is valid blech32, but should be blech32m
         );
 
         let address: Result<Address, _> = "el1qq0umk3pez693jrrlxz9ndlkuwne93gdu9g83mhhzuyf46e3mdzfpva0w48gqgzgrklncnm0k5zeyw8my2ypfsnnmzrstzt7de".parse();
         assert_eq!(
             address.err().unwrap().to_string(),
-            "v0 witness program must use b(l)ech32 not b(l)ech32m",
+            "blech32 error: invalid checksum", // is valid blech32m, but should be blech32
         );
 
-        let address: Result<Address, _> = "ert130xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqqu2tys".parse();
+        let address: Result<Address, _> =
+            "ert130xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqqu2tys".parse();
         assert_eq!(
             address.err().unwrap().to_string(),
-            "invalid witness script version: 17",
+            "bech32 error: invalid segwit witness version: 17 (bech32 character: '3')",
         );
 
         let address: Result<Address, _> = "el1pq0umk3pez693jrrlxz9ndlkuwne93gdu9g83mhhzuyf46e3mdzfpva0w48gqgzgrklncnm0k5zeyw8my2ypfsqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpe9jfn0gypaj".parse();
         assert_eq!(
             address.err().unwrap().to_string(),
-            "the witness program must be between 2 and 40 bytes in length, not 41",
+            "blech32 error: invalid witness length",
         );
 
         // "invalid prefix" gives a weird error message because we do
         // a dumb prefix check before even attempting bech32 decoding
         let address: Result<Address, _> = "rrr1qq0umk3pez693jrrlxz9ndlkuwne93gdu9g83mhhzuyf46e3mdzfpva0w48gqgzgrklncnm0k5zeyw8my2ypfs2d9rp7meq4kg".parse();
-        assert_eq!(
-            address.err().unwrap().to_string(),
-            "base58 error: invalid base58 character 0x30",
-        );
+        assert_eq!(address.err().unwrap().to_string(), "base58 error: decode",);
+    }
+
+    #[test]
+    fn test_fixed_addresses() {
+        let pk = bitcoin::PublicKey::from_str(
+            "0212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea",
+        )
+        .unwrap();
+        let script = Script::default();
+        let secp = Secp256k1::verification_only();
+        let internal_key = UntweakedPublicKey::from_str(
+            "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51",
+        )
+        .unwrap();
+        let tap_node_hash = TapNodeHash::from_byte_array([0; 32]);
+
+        let mut expected = IntoIterator::into_iter([
+            "2dszRCFv8Ub4ytKo1Q1vXXGgSx7mekNDwSJ",
+            "XToMocNywBYNSiXUe5xvoa2naAps9Ek1hq",
+            "ert1qew0l0emv7449u7hqgc8utzdzryhse79yhq2sxv",
+            "XZF6k8S6eoVxXMB4NpWjh2s7LjQUP7pw2R",
+            "ert1quwcvgs5clswpfxhm7nyfjmaeysn6us0yvjdexn9yjkv3k7zjhp2szaqlpq",
+            "ert1p8qs0qcn25l2y6yvtc5t95rr8w9pndcj64c8rkutnvkcvdp6gh02q2cqvj9",
+            "ert1pxrrurkg8j8pve97lffvv2y67cf7ux478h077c87qacqzhue7390sqkjp06",
+            "CTEkC79sYAvWNcxd8iTYnYo226FqRBbzBcMppq7L2dA8jVXJWoo1kKWB3UBLY6gBjiXf87ibs8c6mQyZ",
+            "AzpjUhKMLJi9y2oLt3ZdM3BP9nHdLPJfGMVxRBaRc2gDpeNqPMVpShTszJW7bX42vT2KoejYy8GtbcxH",
+            "el1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4jul7lnkeat2teawq3s0cky6yxf0pnu2gmz9ej9kyq5yc",
+            "AzpjUhKMLJi9y2oLt3ZdM3BP9nHdLPJfGMVxRBaRc2gDpeNvq6SLVpBVwtakF6nmUFundyW7YjUdVkpr",
+            "el1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4casc3pf3lquzjd0haxgn9hmjfp84eq7geymjdx2f9verdu99wz4h79u87cnxdzq",
+            "el1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5wpq7p3x4f75f5gch3gktgxxwu2rxm394tsw8dchxedsc6r53w75cj24fq2u2ls5",
+            "el1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5vx8c8vs0ywzejta7jjcc5f4asnacdtu0wlaas0upmsq90enaz2lhjd0k0q7qn4h",
+            "QFq3vvrr6Ub2KAyb3LdoCxEQvKukB6nN9i",
+            "GydeMhecNgrq17WMkyyTM4ETv1YubMVtLN",
+            "ex1qew0l0emv7449u7hqgc8utzdzryhse79ydjqgek",
+            "H55PJDhj6JpR5k9wViXGEX4nga8WmhXtnD",
+            "ex1quwcvgs5clswpfxhm7nyfjmaeysn6us0yvjdexn9yjkv3k7zjhp2s4sla8h",
+            "ex1p8qs0qcn25l2y6yvtc5t95rr8w9pndcj64c8rkutnvkcvdp6gh02qa4lw5j",
+            "ex1pxrrurkg8j8pve97lffvv2y67cf7ux478h077c87qacqzhue7390shmdrfd",
+            "VTptY6cqJbusNpL5xvo8VL38nLX9PGDjfYQfqhu9EaA7FtuidkWyQzMHY9jzZrpBcCXT437vM6V4N8kh",
+            "VJL64Ep3rcngP4cScRme15q9i8MCNiuqWeiG3YbtduUidVyorg7nRsgmmF714QtH3sNpWB2CqsVVciQh",
+            "lq1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4jul7lnkeat2teawq3s0cky6yxf0pnu2gs2923tg58xcz",
+            "VJL64Ep3rcngP4cScRme15q9i8MCNiuqWeiG3YbtduUidVyuJR4JUzQPiqBdhzd1bgGHLVnmRUjfHc68",
+            "lq1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4casc3pf3lquzjd0haxgn9hmjfp84eq7geymjdx2f9verdu99wz47jmkmgmr9a4s",
+            "lq1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5wpq7p3x4f75f5gch3gktgxxwu2rxm394tsw8dchxedsc6r53w75375l4kfvf08y",
+            "lq1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5vx8c8vs0ywzejta7jjcc5f4asnacdtu0wlaas0upmsq90enaz2l77n92erwrrz8",
+            "FojPFeboBgrd953mXXe72KWthjVwHWozqN",
+            "8vsafXgrB5bJeSidGbK5eYnjKvQ3RiB4BB",
+            "tex1qew0l0emv7449u7hqgc8utzdzryhse79yh5jp9a",
+            "92KKc3jxthYtj5ND1KrtY1d46UyeWV6XbP",
+            "tex1quwcvgs5clswpfxhm7nyfjmaeysn6us0yvjdexn9yjkv3k7zjhp2s5fd6kc",
+            "tex1p8qs0qcn25l2y6yvtc5t95rr8w9pndcj64c8rkutnvkcvdp6gh02quvdf9a",
+            "tex1pxrrurkg8j8pve97lffvv2y67cf7ux478h077c87qacqzhue7390skzlycz",
+            "vtS71VhcpFt978sha5d1L2gCzp3UL5kXacRpb3N4GTW5MwvBzz5HwxYyB8Pns4yM2dd2osmQkHSkp88u",
+            "vjTuLJ76nGi8PUopBVmGK8bLKPfBpaBWf6wKfn8z9Vdz6ubVhpvmMr6TK2RcqAYiujN1g1uwg8kejrM3",
+            "tlq1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4jul7lnkeat2teawq3s0cky6yxf0pnu2gq8g2kuxfj8ft",
+            "vjTuLJ76nGi8PUopBVmGK8bLKPfBpaBWf6wKfn8z9Vdz6ubb9ZsHQxp5GcWFUkHTTYFUWLgWFk1DN5Fe",
+            "tlq1qqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww4casc3pf3lquzjd0haxgn9hmjfp84eq7geymjdx2f9verdu99wz4e6vcdfcyp5m8",
+            "tlq1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5wpq7p3x4f75f5gch3gktgxxwu2rxm394tsw8dchxedsc6r53w75kkr3rh2tdxfn",
+            "tlq1pqgft7r4ytdenml0gaj67393sd3qkt3nxex0ut5dt3plhzwf6jaww5vx8c8vs0ywzejta7jjcc5f4asnacdtu0wlaas0upmsq90enaz2lekytucqf82vs",
+        ]);
+
+        for params in [
+            &AddressParams::ELEMENTS,
+            &AddressParams::LIQUID,
+            &AddressParams::LIQUID_TESTNET,
+        ] {
+            for blinder in [None, Some(pk.inner)] {
+                let addr = Address::p2pkh(&pk, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2sh(&script, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2wpkh(&pk, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2shwpkh(&pk, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2wsh(&script, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2tr(&secp, internal_key, None, blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+
+                let addr = Address::p2tr(&secp, internal_key, Some(tap_node_hash), blinder, params);
+                assert_eq!(&addr.to_string(), expected.next().unwrap());
+            }
+        }
     }
 }
diff --git a/src/blech32.rs b/src/blech32.rs
deleted file mode 100644
index 75f52e16..00000000
--- a/src/blech32.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-// Rust Elements Library
-// Written by
-//   The Elements developers
-//
-// To the extent possible under law, the author(s) have dedicated all
-// copyright and related and neighboring rights to this software to
-// the public domain worldwide. This software is distributed without
-// any warranty.
-//
-// You should have received a copy of the CC0 Public Domain Dedication
-// along with this software.
-// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
-
-// This file is an adaptation of the bech32 crate with the following
-// license notice:
-//
-// Copyright (c) 2017 Clark Moody
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! # Blech32
-//!
-//! A variation of the bech32 encoding for blinded Elements addresses.
-
-// Original documentation is left untouched, so it corresponds to bech32.
-
-use std::fmt;
-
-use bitcoin::bech32::{u5, Error};
-
-/// Used for encode/decode operations for the two variants of Blech32
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub enum Variant {
-    /// The original Blech32
-    Blech32,
-    /// The improved Blech32m
-    Blech32m,
-}
-
-const BLECH32_CONST: u64 = 1;
-const BLECH32M_CONST: u64 = 0x455972a3350f7a1;
-
-impl Variant {
-    // Produce the variant based on the remainder of the polymod operation
-    fn from_remainder(c: u64) -> Option<Self> {
-        match c {
-            BLECH32_CONST => Some(Variant::Blech32),
-            BLECH32M_CONST => Some(Variant::Blech32m),
-            _ => None,
-        }
-    }
-
-    fn constant(self) -> u64 {
-        match self {
-            Variant::Blech32 => BLECH32_CONST,
-            Variant::Blech32m => BLECH32M_CONST,
-        }
-    }
-}
-
-/// Encode a bech32 payload to an [fmt::Formatter].
-pub fn encode_to_fmt<T: AsRef<[u5]>>(
-    fmt: &mut dyn fmt::Write,
-    hrp: &str,
-    data: T,
-    variant: Variant,
-) -> fmt::Result {
-    let hrp_bytes: &[u8] = hrp.as_bytes();
-    let checksum = create_checksum(hrp_bytes, data.as_ref(), variant);
-    let data_part = data.as_ref().iter().chain(checksum.iter());
-
-    write!(
-        fmt,
-        "{}{}{}",
-        hrp,
-        SEP,
-        data_part
-            .map(|p| CHARSET[*p.as_ref() as usize])
-            .collect::<String>()
-    )
-}
-
-/// Decode a bech32 string into the raw HRP and the data bytes.
-/// The HRP is returned as it was found in the original string,
-/// so it can be either lower or upper case.
-pub fn decode(s: &str) -> Result<(&str, Vec<u5>, Variant), Error> {
-    // Ensure overall length is within bounds
-    let len: usize = s.len();
-    // ELEMENTS: 8->14
-    if len < 14 {
-        return Err(Error::InvalidLength);
-    }
-
-    // Split at separator and check for two pieces
-    let (raw_hrp, raw_data) = match s.rfind('1') {
-        None => return Err(Error::MissingSeparator),
-        Some(sep) => {
-            let (hrp, data) = s.split_at(sep);
-            (hrp, &data[1..])
-        }
-    };
-    // ELEMENTS: 6->12
-    if raw_hrp.is_empty() || raw_data.len() < 12 || raw_hrp.len() > 83 {
-        return Err(Error::InvalidLength);
-    }
-
-    let mut has_lower: bool = false;
-    let mut has_upper: bool = false;
-    let mut hrp_bytes: Vec<u8> = Vec::new();
-    for b in raw_hrp.bytes() {
-        // Valid subset of ASCII
-        if b < 33 || b > 126 {
-            return Err(Error::InvalidChar(b as char));
-        }
-        let mut c = b;
-        // Lowercase
-        if b >= b'a' && b <= b'z' {
-            has_lower = true;
-        }
-        // Uppercase
-        if b >= b'A' && b <= b'Z' {
-            has_upper = true;
-            // Convert to lowercase
-            c = b + (b'a' - b'A');
-        }
-        hrp_bytes.push(c);
-    }
-
-    // Check data payload
-    let mut data = raw_data
-        .chars()
-        .map(|c| {
-            // Only check if c is in the ASCII range, all invalid ASCII characters have the value -1
-            // in CHARSET_REV (which covers the whole ASCII range) and will be filtered out later.
-            if !c.is_ascii() {
-                return Err(Error::InvalidChar(c));
-            }
-
-            if c.is_lowercase() {
-                has_lower = true;
-            } else if c.is_uppercase() {
-                has_upper = true;
-            }
-
-            // c should be <128 since it is in the ASCII range, CHARSET_REV.len() == 128
-            let num_value = CHARSET_REV[c as usize];
-
-            if num_value > 31 || num_value < 0 {
-                return Err(Error::InvalidChar(c));
-            }
-
-            Ok(u5::try_from_u8(num_value as u8).expect("range checked above, num_value <= 31"))
-        })
-        .collect::<Result<Vec<u5>, Error>>()?;
-
-    // Ensure no mixed case
-    if has_lower && has_upper {
-        return Err(Error::MixedCase);
-    }
-
-    // Ensure checksum
-    match verify_checksum(&raw_hrp.as_bytes(), &data) {
-        Some(variant) => {
-            // Remove checksum from data payload
-            let dbl: usize = data.len();
-            data.truncate(dbl - 12);
-
-            Ok((raw_hrp, data, variant))
-        }
-        None => Err(Error::InvalidChecksum),
-    }
-}
-
-fn create_checksum(hrp: &[u8], data: &[u5], variant: Variant) -> Vec<u5> {
-    let mut values: Vec<u5> = hrp_expand(hrp);
-    values.extend_from_slice(data);
-    // Pad with 12 zeros
-    values.extend_from_slice(&[u5::try_from_u8(0).unwrap(); 12]); // ELEMENTS: 6->12
-    let plm: u64 = polymod(&values) ^ variant.constant();
-    let mut checksum: Vec<u5> = Vec::new();
-    // ELEMENTS: 6->12
-    for p in 0..12 {
-        checksum.push(u5::try_from_u8(((plm >> (5 * (11 - p))) & 0x1f) as u8).unwrap()); // ELEMENTS: 5->11
-    }
-    checksum
-}
-
-fn verify_checksum(hrp: &[u8], data: &[u5]) -> Option<Variant> {
-    let mut exp = hrp_expand(hrp);
-    exp.extend_from_slice(data);
-    Variant::from_remainder(polymod(&exp))
-}
-
-fn hrp_expand(hrp: &[u8]) -> Vec<u5> {
-    let mut v: Vec<u5> = Vec::new();
-    for b in hrp {
-        v.push(u5::try_from_u8(*b >> 5).expect("can't be out of range, max. 7"));
-    }
-    v.push(u5::try_from_u8(0).unwrap());
-    for b in hrp {
-        v.push(u5::try_from_u8(*b & 0x1f).expect("can't be out of range, max. 31"));
-    }
-    v
-}
-
-fn polymod(values: &[u5]) -> u64 {
-    let mut chk: u64 = 1;
-    let mut b: u8;
-    for v in values {
-        b = (chk >> 55) as u8; // ELEMENTS: 25->55
-        chk = (chk & 0x7fffffffffffff) << 5 ^ (u64::from(*v.as_ref())); // ELEMENTS 0x1ffffff->0x7fffffffffffff
-        for (i, coef) in GEN.iter().enumerate() {
-            if (b >> i) & 1 == 1 {
-                chk ^= coef
-            }
-        }
-    }
-    chk
-}
-
-/// Human-readable part and data part separator
-const SEP: char = '1';
-
-/// Encoding character set. Maps data value -> char
-const CHARSET: [char; 32] = [
-    'q', 'p', 'z', 'r', 'y', '9', 'x', '8', 'g', 'f', '2', 't', 'v', 'd', 'w', '0', 's', '3', 'j',
-    'n', '5', '4', 'k', 'h', 'c', 'e', '6', 'm', 'u', 'a', '7', 'l',
-];
-
-// Reverse character set. Maps ASCII byte -> CHARSET index on [0,31]
-const CHARSET_REV: [i8; 128] = [
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1, -1, 29, -1, 24, 13, 25, 9, 8, 23,
-    -1, 18, 22, 31, 27, 19, -1, 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1, -1, 29,
-    -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1,
-    -1, -1, -1, -1,
-];
-
-/// Generator coefficients
-const GEN: [u64; 5] = [
-    // ELEMENTS
-    0x7d52fba40bd886,
-    0x5e8dbf1a03950c,
-    0x1c3a3c74072a18,
-    0x385d72fa0e5139,
-    0x7093e5a608865b,
-];
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    use bitcoin::bech32::ToBase32;
-    use rand;
-
-    #[test]
-    fn test_polymod_sanity() {
-        let data: [u8; 32] = rand::random();
-
-        let data1 = data.to_vec();
-        let data1_b32 = data1.to_base32();
-        let polymod1 = polymod(&data1_b32);
-
-        let data2 = data.to_vec();
-        let mut data2_b32 = data2.to_base32();
-                data2_b32.extend(vec![u5::try_from_u8(0).unwrap(); 1023]);
-        let polymod2 = polymod(&data2_b32);
-        assert_eq!(polymod1, polymod2);
-    }
-
-    #[test]
-    fn test_checksum() {
-        let data = vec![7,2,3,4,5,6,7,8,9,234,123,213,16];
-        let cs = create_checksum(b"lq", &data.to_base32(), Variant::Blech32);
-        let expected_cs = vec![22,13,13,5,4,4,23,7,28,21,30,12];
-        for i in 0..expected_cs.len() {
-            assert_eq!(expected_cs[i], *cs[i].as_ref());
-        }
-    }
-}
diff --git a/src/blech32/decode.rs b/src/blech32/decode.rs
new file mode 100644
index 00000000..8a504bbb
--- /dev/null
+++ b/src/blech32/decode.rs
@@ -0,0 +1,900 @@
+//
+// This file is essentially a copy of src/primitives/decode.rs from the bech32
+// crate. It is not public-domain licensed. It is MIT-licensed. The changes are:
+//   * Imports changed to use the public bech32 crate
+//   * Bech32 changed to Blech32 by search-and-replace
+//   * Fe32::from_char_unchecked and .0 were changed to use public API
+//   * CheckedHrpstring::validate_witness_program_length replaced to use Elements limits
+//   * `std` feature gates were removed
+//   * a couple tests with fixed vectors were disabled since we replaced the checksum
+//   * doccomment examples with fixed vectors were removed
+//
+
+// Copyright (c) 2023 Tobin Harding and Andrew Poelstra
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//! Decoding of bech32 encoded strings as specified by [BIP-173] and [BIP-350].
+//!
+//! You should only need to use this module directly if you want control over exactly what is
+//! checked and when it is checked (correct bech32 characters, valid checksum, valid checksum for
+//! specific checksum algorithm, etc). If you are parsing/validating modern (post BIP-350) bitcoin
+//! segwit addresses consider using the higher crate level API.
+//!
+//! If you do find yourself using this module directly then consider using the most general type
+//! that serves your purposes, each type can be created by parsing an address string to `new`. You
+//! likely do not want to arbitrarily transition from one type to the next even though possible. And
+//! be prepared to spend some time with the bips - you have been warned :)
+//!
+//! # Details
+//!
+//! A Blech32 string is at most 90 characters long and consists of:
+//!
+//! - The human-readable part, which is intended to convey the type of data, or anything else that
+//!   is relevant to the reader. This part MUST contain 1 to 83 US-ASCII characters.
+//! - The separator, which is always "1".
+//! - The data part, which is at least 6 characters long and only consists of alphanumeric
+//!   characters excluding "1", "b", "i", and "o".
+//!
+//! The types in this module heavily lean on the wording in BIP-173: *We first
+//! describe the general checksummed base32 format called Blech32 and then define Segregated Witness
+//! addresses using it.*
+//!
+//! - `UncheckedHrpstring`: Parses the general checksummed base32 format and provides checksum validation.
+//! - `CheckedHrpstring`: Provides access to the data encoded by a general checksummed base32 string and segwit checks.
+//! - `SegwitHrpstring`: Provides access to the data encoded by a segwit address.
+//!
+//! [BIP-173]: <https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki>
+//! [BIP-350]: <https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki>
+
+use core::{fmt, iter, slice, str};
+
+use crate::error::write_err;
+use bech32::primitives::checksum::{self, Checksum};
+use bech32::primitives::gf32::Fe32;
+use bech32::primitives::hrp::{self, Hrp};
+use bech32::primitives::iter::{Fe32IterExt, FesToBytes};
+use bech32::primitives::segwit::{WitnessLengthError, VERSION_0};
+use super::{Blech32, Blech32m};
+
+/// Separator between the hrp and payload (as defined by BIP-173).
+const SEP: char = '1';
+
+/// An HRP string that has been parsed but not yet had the checksum checked.
+///
+/// Parsing an HRP string only checks validity of the characters, it does not validate the
+/// checksum in any way.
+///
+/// Unless you are attempting to validate a string with multiple checksums then you likely do not
+/// want to use this type directly, instead use [`CheckedHrpstring::new`].
+#[derive(Debug)]
+pub struct UncheckedHrpstring<'s> {
+    /// The human-readable part, guaranteed to be lowercase ASCII characters.
+    hrp: Hrp,
+    /// This is ASCII byte values of the parsed string, guaranteed to be valid bech32 characters.
+    ///
+    /// Contains the checksum if one was present in the parsed string.
+    data: &'s [u8],
+}
+
+impl<'s> UncheckedHrpstring<'s> {
+    /// Parses an bech32 encode string and constructs a [`UncheckedHrpstring`] object.
+    ///
+    /// Checks for valid ASCII values, does not validate the checksum.
+    #[inline]
+    pub fn new(s: &'s str) -> Result<Self, UncheckedHrpstringError> {
+        let sep_pos = check_characters(s)?;
+        let (hrp, data) = s.split_at(sep_pos);
+
+        let ret = UncheckedHrpstring {
+            hrp: Hrp::parse(hrp)?,
+            data: &data.as_bytes()[1..], // Skip the separator.
+        };
+
+        Ok(ret)
+    }
+
+    /// Returns the human-readable part.
+    #[inline]
+    pub fn hrp(&self) -> Hrp { self.hrp }
+
+    /// Validates that data has a valid checksum for the `Ck` algorithm and returns a [`CheckedHrpstring`].
+    #[inline]
+    pub fn validate_and_remove_checksum<Ck: Checksum>(
+        self,
+    ) -> Result<CheckedHrpstring<'s>, ChecksumError> {
+        self.validate_checksum::<Ck>()?;
+        Ok(self.remove_checksum::<Ck>())
+    }
+
+    /// Validates that data has a valid checksum for the `Ck` algorithm (this may mean an empty
+    /// checksum if `NoChecksum` is used).
+    ///
+    /// This is useful if you do not know which checksum algorithm was used and wish to validate
+    /// against multiple algorithms consecutively. If this function returns `true` then call
+    /// `remove_checksum` to get a [`CheckedHrpstring`].
+    #[inline]
+    pub fn has_valid_checksum<Ck: Checksum>(&self) -> bool {
+        self.validate_checksum::<Ck>().is_ok()
+    }
+
+    /// Validates that data has a valid checksum for the `Ck` algorithm (this may mean an empty
+    /// checksum if `NoChecksum` is used).
+    #[inline]
+    pub fn validate_checksum<Ck: Checksum>(&self) -> Result<(), ChecksumError> {
+        use ChecksumError as E;
+
+        if Ck::CHECKSUM_LENGTH == 0 {
+            // Called with NoChecksum
+            return Ok(());
+        }
+
+        if self.data.len() < Ck::CHECKSUM_LENGTH {
+            return Err(E::InvalidChecksumLength);
+        }
+
+        let mut checksum_eng = checksum::Engine::<Ck>::new();
+        checksum_eng.input_hrp(self.hrp());
+
+        // Unwrap ok since we checked all characters in our constructor.
+        for fe in self.data.iter().map(|&b| Fe32::from_char(b.into()).unwrap()) {
+            checksum_eng.input_fe(fe);
+        }
+
+        if checksum_eng.residue() != &Ck::TARGET_RESIDUE {
+            return Err(E::InvalidChecksum);
+        }
+
+        Ok(())
+    }
+
+    /// Removes the checksum for the `Ck` algorithm and returns an [`CheckedHrpstring`].
+    ///
+    /// Data must be valid (ie, first call `has_valid_checksum` or `validate_checksum()`). This
+    /// function is typically paired with `has_valid_checksum` when validating against multiple
+    /// checksum algorithms consecutively.
+    ///
+    /// # Panics
+    ///
+    /// May panic if data is not valid.
+    #[inline]
+    pub fn remove_checksum<Ck: Checksum>(self) -> CheckedHrpstring<'s> {
+        let data_len = self.data.len() - Ck::CHECKSUM_LENGTH;
+
+        CheckedHrpstring { hrp: self.hrp(), data: &self.data[..data_len] }
+    }
+}
+
+/// An HRP string that has been parsed and had the checksum validated.
+///
+/// This type does not treat the first byte of the data in any special way i.e., as the witness
+/// version byte. If you are parsing Bitcoin segwit addresses you likely want to use [`SegwitHrpstring`].
+///
+/// > We first describe the general checksummed base32 format called Blech32 and then
+/// > define Segregated Witness addresses using it.
+///
+/// This type abstracts over the general checksummed base32 format called Blech32.
+#[derive(Debug)]
+pub struct CheckedHrpstring<'s> {
+    /// The human-readable part, guaranteed to be lowercase ASCII characters.
+    hrp: Hrp,
+    /// This is ASCII byte values of the parsed string, guaranteed to be valid bech32 characters,
+    /// with the checksum removed.
+    data: &'s [u8],
+}
+
+impl<'s> CheckedHrpstring<'s> {
+    /// Parses and validates an HRP string, without treating the first data character specially.
+    ///
+    /// If you are validating the checksum multiple times consider using [`UncheckedHrpstring`].
+    ///
+    /// This is equivalent to `UncheckedHrpstring::new().validate_and_remove_checksum::<CK>()`.
+    #[inline]
+    pub fn new<Ck: Checksum>(s: &'s str) -> Result<Self, CheckedHrpstringError> {
+        let unchecked = UncheckedHrpstring::new(s)?;
+        let checked = unchecked.validate_and_remove_checksum::<Ck>()?;
+        Ok(checked)
+    }
+
+    /// Returns the human-readable part.
+    #[inline]
+    pub fn hrp(&self) -> Hrp { self.hrp }
+
+    /// Returns an iterator that yields the data part of the parsed bech32 encoded string.
+    ///
+    /// Converts the ASCII bytes representing field elements to the respective field elements, then
+    /// converts the stream of field elements to a stream of bytes.
+    #[inline]
+    pub fn byte_iter(&self) -> ByteIter<'_> {
+        ByteIter { iter: AsciiToFe32Iter { iter: self.data.iter().copied() }.fes_to_bytes() }
+    }
+
+    /// Converts this type to a [`SegwitHrpstring`] after validating the witness and HRP.
+    #[inline]
+    pub fn validate_segwit(mut self) -> Result<SegwitHrpstring<'s>, SegwitHrpstringError> {
+        if self.data.is_empty() {
+            return Err(SegwitHrpstringError::MissingWitnessVersion);
+        }
+        // Unwrap ok since check_characters checked the bech32-ness of this char.
+        let witness_version = Fe32::from_char(self.data[0].into()).unwrap();
+        self.data = &self.data[1..]; // Remove the witness version byte from data.
+
+        self.validate_padding()?;
+        self.validate_witness_program_length(witness_version)?;
+
+        Ok(SegwitHrpstring { hrp: self.hrp(), witness_version, data: self.data })
+    }
+
+    /// Validates the segwit padding rules.
+    ///
+    /// Must be called after the witness version byte is removed from the data.
+    ///
+    /// From BIP-173:
+    /// > Re-arrange those bits into groups of 8 bits. Any incomplete group at the
+    /// > end MUST be 4 bits or less, MUST be all zeroes, and is discarded.
+    fn validate_padding(&self) -> Result<(), PaddingError> {
+        if self.data.is_empty() {
+            return Ok(()); // Empty data implies correct padding.
+        }
+
+        let fe_iter = AsciiToFe32Iter { iter: self.data.iter().copied() };
+        let padding_len = fe_iter.len() * 5 % 8;
+
+        if padding_len > 4 {
+            return Err(PaddingError::TooMuch);
+        }
+
+        let last_fe = fe_iter.last().expect("checked above");
+        let last_byte = last_fe.to_u8();
+
+        let padding_contains_non_zero_bits = match padding_len {
+            0 => false,
+            1 => last_byte & 0b0001 > 0,
+            2 => last_byte & 0b0011 > 0,
+            3 => last_byte & 0b0111 > 0,
+            4 => last_byte & 0b1111 > 0,
+            _ => unreachable!("checked above"),
+        };
+        if padding_contains_non_zero_bits {
+            Err(PaddingError::NonZero)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Validates the segwit witness length rules.
+    ///
+    /// Must be called after the witness version byte is removed from the data.
+    fn validate_witness_program_length(
+        &self,
+        witness_version: Fe32,
+    ) -> Result<(), WitnessLengthError> {
+        let len = self.byte_iter().len();
+        if len < 2 {
+            Err(WitnessLengthError::TooShort)
+        } else if len > 40 + 33 {
+            Err(WitnessLengthError::TooLong)
+        } else if witness_version == Fe32::Q && len != 53 && len != 65 {
+            Err(WitnessLengthError::InvalidSegwitV0)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// An HRP string that has been parsed, had the checksum validated, had the witness version
+/// validated, had the witness data length checked, and the had witness version and checksum
+/// removed.
+///
+#[derive(Debug)]
+pub struct SegwitHrpstring<'s> {
+    /// The human-readable part, valid for segwit addresses.
+    hrp: Hrp,
+    /// The first byte of the parsed data.
+    witness_version: Fe32,
+    /// This is ASCII byte values of the parsed string, guaranteed to be valid bech32 characters,
+    /// with the witness version and checksum removed.
+    data: &'s [u8],
+}
+
+impl<'s> SegwitHrpstring<'s> {
+    /// Parses an HRP string, treating the first data character as a witness version.
+    ///
+    /// The version byte does not appear in the extracted binary data, but is covered by the
+    /// checksum. It can be accessed with [`Self::witness_version`].
+    ///
+    /// NOTE: We do not enforce any restrictions on the HRP, use [`SegwitHrpstring::has_valid_hrp`]
+    /// to get strict BIP conformance (also [`Hrp::is_valid_on_mainnet`] and friends).
+    #[inline]
+    pub fn new(s: &'s str) -> Result<Self, SegwitHrpstringError> {
+        let unchecked = UncheckedHrpstring::new(s)?;
+
+        if unchecked.data.is_empty() {
+            return Err(SegwitHrpstringError::MissingWitnessVersion);
+        }
+
+        // Unwrap ok since check_characters (in `Self::new`) checked the bech32-ness of this char.
+        let witness_version = Fe32::from_char(unchecked.data[0].into()).unwrap();
+        if witness_version.to_u8() > 16 {
+            return Err(SegwitHrpstringError::InvalidWitnessVersion(witness_version));
+        }
+
+        let checked: CheckedHrpstring<'s> = match witness_version {
+            VERSION_0 => unchecked.validate_and_remove_checksum::<Blech32>()?,
+            _ => unchecked.validate_and_remove_checksum::<Blech32m>()?,
+        };
+
+        checked.validate_segwit()
+    }
+
+    /// Parses an HRP string, treating the first data character as a witness version.
+    ///
+    /// ## WARNING
+    ///
+    /// You almost certainly do not want to use this function.
+    ///
+    /// It is provided for backwards comparability to parse addresses that have an non-zero witness
+    /// version because [BIP-173] explicitly allows using the bech32 checksum with any witness
+    /// version however [BIP-350] specifies all witness version > 0 now MUST use bech32m.
+    ///
+    /// [BIP-173]: https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+    /// [BIP-350]: https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
+    #[inline]
+    pub fn new_bech32(s: &'s str) -> Result<Self, SegwitHrpstringError> {
+        let unchecked = UncheckedHrpstring::new(s)?;
+
+        // Unwrap ok since check_characters (in `Self::new`) checked the bech32-ness of this char.
+        let witness_version = Fe32::from_char(unchecked.data[0].into()).unwrap();
+        if witness_version.to_u8() > 16 {
+            return Err(SegwitHrpstringError::InvalidWitnessVersion(witness_version));
+        }
+
+        let checked = unchecked.validate_and_remove_checksum::<Blech32>()?;
+        checked.validate_segwit()
+    }
+
+    /// Returns `true` if the HRP is "bc" or "tb".
+    ///
+    /// BIP-173 requires that the HRP is "bc" or "tb" but software in the Bitcoin ecosystem uses
+    /// other HRPs, specifically "bcrt" for regtest addresses. We provide this function in order to
+    /// be BIP-173 compliant but their are no restrictions on the HRP of [`SegwitHrpstring`].
+    #[inline]
+    pub fn has_valid_hrp(&self) -> bool { self.hrp().is_valid_segwit() }
+
+    /// Returns the human-readable part.
+    #[inline]
+    pub fn hrp(&self) -> Hrp { self.hrp }
+
+    /// Returns the witness version.
+    #[inline]
+    pub fn witness_version(&self) -> Fe32 { self.witness_version }
+
+    /// Returns an iterator that yields the data part, excluding the witness version, of the parsed
+    /// bech32 encoded string.
+    ///
+    /// Converts the ASCII bytes representing field elements to the respective field elements, then
+    /// converts the stream of field elements to a stream of bytes.
+    ///
+    /// Use `self.witness_version()` to get the witness version.
+    #[inline]
+    pub fn byte_iter(&self) -> ByteIter<'_> {
+        ByteIter { iter: AsciiToFe32Iter { iter: self.data.iter().copied() }.fes_to_bytes() }
+    }
+}
+
+/// Checks whether a given HRP string has data characters in the bech32 alphabet (incl. checksum
+/// characters), and that the whole string has consistent casing (hrp, data, and checksum).
+///
+/// # Returns
+///
+/// The byte-index into the string where the '1' separator occurs, or an error if it does not.
+fn check_characters(s: &str) -> Result<usize, CharError> {
+    use CharError as E;
+
+    let mut has_upper = false;
+    let mut has_lower = false;
+    let mut req_bech32 = true;
+    let mut sep_pos = None;
+    for (n, ch) in s.char_indices().rev() {
+        if ch == SEP && sep_pos.is_none() {
+            req_bech32 = false;
+            sep_pos = Some(n);
+        }
+        if req_bech32 {
+            Fe32::from_char(ch).map_err(|_| E::InvalidChar(ch))?;
+        }
+        if ch.is_ascii_uppercase() {
+            has_upper = true;
+        } else if ch.is_ascii_lowercase() {
+            has_lower = true;
+        }
+    }
+    if has_upper && has_lower {
+        Err(E::MixedCase)
+    } else if let Some(pos) = sep_pos {
+        Ok(pos)
+    } else {
+        Err(E::MissingSeparator)
+    }
+}
+
+/// An iterator over a parsed HRP string data as bytes.
+pub struct ByteIter<'s> {
+    iter: FesToBytes<AsciiToFe32Iter<iter::Copied<slice::Iter<'s, u8>>>>,
+}
+
+impl Iterator for ByteIter<'_> {
+    type Item = u8;
+    #[inline]
+    fn next(&mut self) -> Option<u8> { self.iter.next() }
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
+}
+
+impl ExactSizeIterator for ByteIter<'_> {
+    #[inline]
+    fn len(&self) -> usize { self.iter.len() }
+}
+
+/// Helper iterator adaptor that maps an iterator of valid bech32 character ASCII bytes to an
+/// iterator of field elements.
+///
+/// # Panics
+///
+/// If any `u8` in the input iterator is out of range for an [`Fe32`]. Should only be used on data
+/// that has already been checked for validity (eg, by using `check_characters`).
+struct AsciiToFe32Iter<I: Iterator<Item = u8>> {
+    iter: I,
+}
+
+impl<I> Iterator for AsciiToFe32Iter<I>
+where
+    I: Iterator<Item = u8>,
+{
+    type Item = Fe32;
+    #[inline]
+    fn next(&mut self) -> Option<Fe32> { self.iter.next().map(|ch| Fe32::from_char(ch.into()).unwrap()) }
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // Each ASCII character is an fe32 so iterators are the same size.
+        self.iter.size_hint()
+    }
+}
+
+impl<I> ExactSizeIterator for AsciiToFe32Iter<I>
+where
+    I: Iterator<Item = u8> + ExactSizeIterator,
+{
+    #[inline]
+    fn len(&self) -> usize { self.iter.len() }
+}
+
+/// An error while constructing a [`SegwitHrpstring`] type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum SegwitHrpstringError {
+    /// Error while parsing the encoded address string.
+    Unchecked(UncheckedHrpstringError),
+    /// The witness version byte is missing.
+    MissingWitnessVersion,
+    /// Invalid witness version (must be 0-16 inclusive).
+    InvalidWitnessVersion(Fe32),
+    /// Invalid padding on the witness data.
+    Padding(PaddingError),
+    /// Invalid witness length.
+    WitnessLength(WitnessLengthError),
+    /// Invalid checksum.
+    Checksum(ChecksumError),
+}
+
+impl fmt::Display for SegwitHrpstringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Unchecked(ref e) => write_err!(f, "parsing unchecked hrpstring failed"; e),
+            Self::MissingWitnessVersion => write!(f, "the witness version byte is missing"),
+            Self::InvalidWitnessVersion(fe) => write!(f, "invalid segwit witness version: {}", fe.to_u8()),
+            Self::Padding(ref e) => write_err!(f, "invalid padding on the witness data"; e),
+            Self::WitnessLength(ref e) => write_err!(f, "invalid witness length"; e),
+            Self::Checksum(ref e) => write_err!(f, "invalid checksum"; e),
+        }
+    }
+}
+
+impl std::error::Error for SegwitHrpstringError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Unchecked(ref e) => Some(e),
+            Self::Padding(ref e) => Some(e),
+            Self::WitnessLength(ref e) => Some(e),
+            Self::Checksum(ref e) => Some(e),
+            Self::MissingWitnessVersion | Self::InvalidWitnessVersion(_) => None,
+        }
+    }
+}
+
+impl From<UncheckedHrpstringError> for SegwitHrpstringError {
+    #[inline]
+    fn from(e: UncheckedHrpstringError) -> Self { Self::Unchecked(e) }
+}
+
+impl From<WitnessLengthError> for SegwitHrpstringError {
+    #[inline]
+    fn from(e: WitnessLengthError) -> Self { Self::WitnessLength(e) }
+}
+
+impl From<PaddingError> for SegwitHrpstringError {
+    #[inline]
+    fn from(e: PaddingError) -> Self { Self::Padding(e) }
+}
+
+impl From<ChecksumError> for SegwitHrpstringError {
+    #[inline]
+    fn from(e: ChecksumError) -> Self { Self::Checksum(e) }
+}
+
+/// An error while constructing a [`CheckedHrpstring`] type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum CheckedHrpstringError {
+    /// Error while parsing the encoded address string.
+    Parse(UncheckedHrpstringError),
+    /// Invalid checksum.
+    Checksum(ChecksumError),
+}
+
+impl fmt::Display for CheckedHrpstringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Parse(ref e) => write_err!(f, "parse failed"; e),
+            Self::Checksum(ref e) => write_err!(f, "invalid checksum"; e),
+        }
+    }
+}
+
+impl std::error::Error for CheckedHrpstringError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Parse(ref e) => Some(e),
+            Self::Checksum(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<UncheckedHrpstringError> for CheckedHrpstringError {
+    #[inline]
+    fn from(e: UncheckedHrpstringError) -> Self { Self::Parse(e) }
+}
+
+impl From<ChecksumError> for CheckedHrpstringError {
+    #[inline]
+    fn from(e: ChecksumError) -> Self { Self::Checksum(e) }
+}
+
+/// Errors when parsing a bech32 encoded string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum UncheckedHrpstringError {
+    /// An error with the characters of the input string.
+    Char(CharError),
+    /// The human-readable part is invalid.
+    Hrp(hrp::Error),
+}
+
+impl fmt::Display for UncheckedHrpstringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Char(ref e) => write_err!(f, "character error"; e),
+            Self::Hrp(ref e) => write_err!(f, "invalid human-readable part"; e),
+        }
+    }
+}
+
+impl std::error::Error for UncheckedHrpstringError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::Char(ref e) => Some(e),
+            Self::Hrp(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<CharError> for UncheckedHrpstringError {
+    #[inline]
+    fn from(e: CharError) -> Self { Self::Char(e) }
+}
+
+impl From<hrp::Error> for UncheckedHrpstringError {
+    #[inline]
+    fn from(e: hrp::Error) -> Self { Self::Hrp(e) }
+}
+
+/// Character errors in a bech32 encoded string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum CharError {
+    /// String does not contain the separator character.
+    MissingSeparator,
+    /// No characters after the separator.
+    NothingAfterSeparator,
+    /// The checksum does not match the rest of the data.
+    InvalidChecksum,
+    /// The checksum is not a valid length.
+    InvalidChecksumLength,
+    /// Some part of the string contains an invalid character.
+    InvalidChar(char),
+    /// The whole string must be of one case.
+    MixedCase,
+}
+
+impl fmt::Display for CharError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::MissingSeparator => write!(f, "missing human-readable separator, \"{}\"", SEP),
+            Self::NothingAfterSeparator => write!(f, "invalid data - no characters after the separator"),
+            Self::InvalidChecksum => write!(f, "invalid checksum"),
+            Self::InvalidChecksumLength => write!(f, "the checksum is not a valid length"),
+            Self::InvalidChar(n) => write!(f, "invalid character (code={})", n),
+            Self::MixedCase => write!(f, "mixed-case strings not allowed"),
+        }
+    }
+}
+
+impl std::error::Error for CharError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::MissingSeparator
+            | Self::NothingAfterSeparator
+            | Self::InvalidChecksum
+            | Self::InvalidChecksumLength
+            | Self::InvalidChar(_)
+            | Self::MixedCase => None,
+        }
+    }
+}
+
+/// Errors in the checksum of a bech32 encoded string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ChecksumError {
+    /// The checksum does not match the rest of the data.
+    InvalidChecksum,
+    /// The checksum is not a valid length.
+    InvalidChecksumLength,
+}
+
+impl fmt::Display for ChecksumError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::InvalidChecksum => write!(f, "invalid checksum"),
+            Self::InvalidChecksumLength => write!(f, "the checksum is not a valid length"),
+        }
+    }
+}
+
+impl std::error::Error for ChecksumError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::InvalidChecksum | Self::InvalidChecksumLength => None,
+        }
+    }
+}
+
+/// Error validating the padding bits on the witness data.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum PaddingError {
+    /// The data payload has too many bits of padding.
+    TooMuch,
+    /// The data payload is padded with non-zero bits.
+    NonZero,
+}
+
+impl fmt::Display for PaddingError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::TooMuch => write!(f, "the data payload has too many bits of padding"),
+            Self::NonZero => write!(f, "the data payload is padded with non-zero bits"),
+        }
+    }
+}
+
+impl std::error::Error for PaddingError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::TooMuch | Self::NonZero => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bip_173_invalid_parsing_fails() {
+        use UncheckedHrpstringError as E;
+
+        let invalid: Vec<(&str, UncheckedHrpstringError)> = vec!(
+            ("\u{20}1nwldj5",
+             // TODO: Rust >= 1.59.0 use Hrp(hrp::Error::InvalidAsciiByte('\u{20}'.try_into().unwrap()))),
+             E::Hrp(hrp::Error::InvalidAsciiByte(32))),
+            ("\u{7F}1axkwrx",
+             E::Hrp(hrp::Error::InvalidAsciiByte(127))),
+            ("\u{80}1eym55h",
+             E::Hrp(hrp::Error::NonAsciiChar('\u{80}'))),
+            ("an84characterslonghumanreadablepartthatcontainsthetheexcludedcharactersbioandnumber11d6pts4",
+             E::Hrp(hrp::Error::TooLong(84))),
+            ("pzry9x0s0muk",
+             E::Char(CharError::MissingSeparator)),
+            ("1pzry9x0s0muk",
+             E::Hrp(hrp::Error::Empty)),
+            ("x1b4n0q5v",
+             E::Char(CharError::InvalidChar('b'))),
+            // "li1dgmt3" in separate test because error is a checksum error.
+            ("de1lg7wt\u{ff}",
+             E::Char(CharError::InvalidChar('\u{ff}'))),
+            // "A1G7SGD8" in separate test because error is a checksum error.
+            ("10a06t8",
+             E::Hrp(hrp::Error::Empty)),
+            ("1qzzfhee",
+             E::Hrp(hrp::Error::Empty)),
+        );
+
+        for (s, want) in invalid {
+            let got = UncheckedHrpstring::new(s).unwrap_err();
+            assert_eq!(got, want);
+        }
+    }
+
+    /*
+    #[test]
+    fn bip_173_invalid_parsing_fails_invalid_checksum() {
+        use ChecksumError as E;
+
+        let err = UncheckedHrpstring::new("li1dgmt3")
+            .expect("string parses correctly")
+            .validate_checksum::<Blech32>()
+            .unwrap_err();
+        assert_eq!(err, E::InvalidChecksumLength);
+
+        let err = UncheckedHrpstring::new("A1G7SGD8")
+            .expect("string parses correctly")
+            .validate_checksum::<Blech32>()
+            .unwrap_err();
+        assert_eq!(err, E::InvalidChecksum);
+    }
+    */
+
+    #[test]
+    fn bip_350_invalid_parsing_fails() {
+        use UncheckedHrpstringError as E;
+
+        let invalid: Vec<(&str, UncheckedHrpstringError)> = vec!(
+            ("\u{20}1xj0phk",
+             // TODO: Rust >= 1.59.0 use Hrp(hrp::Error::InvalidAsciiByte('\u{20}'.try_into().unwrap()))),
+             E::Hrp(hrp::Error::InvalidAsciiByte(32))),
+            ("\u{7F}1g6xzxy",
+             E::Hrp(hrp::Error::InvalidAsciiByte(127))),
+            ("\u{80}1g6xzxy",
+             E::Hrp(hrp::Error::NonAsciiChar('\u{80}'))),
+            ("an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx",
+             E::Hrp(hrp::Error::TooLong(84))),
+            ("qyrz8wqd2c9m",
+             E::Char(CharError::MissingSeparator)),
+            ("1qyrz8wqd2c9m",
+             E::Hrp(hrp::Error::Empty)),
+            ("y1b0jsk6g",
+             E::Char(CharError::InvalidChar('b'))),
+            ("lt1igcx5c0",
+             E::Char(CharError::InvalidChar('i'))),
+            // "in1muywd" in separate test because error is a checksum error.
+            ("mm1crxm3i",
+             E::Char(CharError::InvalidChar('i'))),
+            ("au1s5cgom",
+             E::Char(CharError::InvalidChar('o'))),
+            // "M1VUXWEZ" in separate test because error is a checksum error.
+            ("16plkw9",
+             E::Hrp(hrp::Error::Empty)),
+            ("1p2gdwpf",
+             E::Hrp(hrp::Error::Empty)),
+
+        );
+
+        for (s, want) in invalid {
+            let got = UncheckedHrpstring::new(s).unwrap_err();
+            assert_eq!(got, want);
+        }
+    }
+
+    /*
+    #[test]
+    fn bip_350_invalid_because_of_invalid_checksum() {
+        use ChecksumError::*;
+
+        // Note the "bc1p2" test case is not from the bip test vectors.
+        let invalid: Vec<&str> = vec!["in1muywd", "bc1p2"];
+
+        for s in invalid {
+            let err =
+                UncheckedHrpstring::new(s).unwrap().validate_checksum::<Blech32m>().unwrap_err();
+            assert_eq!(err, InvalidChecksumLength);
+        }
+
+        let err = UncheckedHrpstring::new("M1VUXWEZ")
+            .unwrap()
+            .validate_checksum::<Blech32m>()
+            .unwrap_err();
+        assert_eq!(err, InvalidChecksum);
+    }
+    */
+
+    #[test]
+    fn check_hrp_uppercase_returns_lower() {
+        let addr = "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4";
+        let unchecked = UncheckedHrpstring::new(addr).expect("failed to parse address");
+        assert_eq!(unchecked.hrp(), Hrp::parse_unchecked("bc"));
+    }
+
+    #[test]
+    fn check_hrp_max_length() {
+        let hrps =
+            "an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio";
+
+        let hrp = Hrp::parse_unchecked(hrps);
+        let s = bech32::encode::<Blech32>(hrp, &[]).expect("failed to encode empty buffer");
+
+        let unchecked = UncheckedHrpstring::new(&s).expect("failed to parse address");
+        assert_eq!(unchecked.hrp(), hrp);
+    }
+
+    /*
+    #[test]
+    fn mainnet_valid_addresses() {
+        let addresses = vec![
+            "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
+            "23451QAR0SRRR7XFKVY5L643LYDNW9RE59GTZZLKULZK",
+        ];
+        for valid in addresses {
+            assert!(CheckedHrpstring::new::<Blech32>(valid).is_ok())
+        }
+    }
+    */
+
+    macro_rules! check_invalid_segwit_addresses {
+        ($($test_name:ident, $reason:literal, $address:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    let res = SegwitHrpstring::new($address);
+                    if res.is_ok() {
+                        panic!("{} sting should not be valid: {}", $address, $reason);
+                    }
+                }
+            )*
+        }
+    }
+    check_invalid_segwit_addresses! {
+        invalid_segwit_address_0, "missing hrp", "1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq";
+        invalid_segwit_address_1, "missing data-checksum", "91111";
+        invalid_segwit_address_2, "invalid witness version", "bc14r0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq";
+        invalid_segwit_address_3, "invalid checksum length", "bc1q5mdq";
+        invalid_segwit_address_4, "missing data", "bc1qwf5mdq";
+        invalid_segwit_address_5, "invalid program length", "bc14r0srrr7xfkvy5l643lydnw9rewf5mdq";
+    }
+}
diff --git a/src/blech32/mod.rs b/src/blech32/mod.rs
new file mode 100644
index 00000000..c4c2d5e6
--- /dev/null
+++ b/src/blech32/mod.rs
@@ -0,0 +1,61 @@
+// This file is an adaptation of the segwit-specific parts of the bech32 crate.
+// Rust Elements Library
+// Written in 2024 by
+//   Andrew Poelstra <apoelstra@blockstream.com>
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//! Blech32-Encoding (Elements Segwit) Support
+//!
+//! A variation of the bech32 encoding for blinded Elements addresses.
+//!
+
+pub mod decode;
+
+// *** Definitions of checksums ***
+
+/// The blech32 checksum algorithm.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Blech32 {}
+
+impl bech32::Checksum for Blech32 {
+    type MidstateRepr = u64;
+    const CHECKSUM_LENGTH: usize = 12;
+    const GENERATOR_SH: [u64; 5] = [
+        0x7d_52fb_a40b_d886,
+        0x5e_8dbf_1a03_950c,
+        0x1c_3a3c_7407_2a18,
+        0x38_5d72_fa0e_5139,
+        0x70_93e5_a608_865b,
+    ];
+    const TARGET_RESIDUE: u64 = 1;
+
+    const CODE_LENGTH: usize = 1024;
+}
+
+/// The blech32m checksum algorithm.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Blech32m {}
+
+impl bech32::Checksum for Blech32m {
+    type MidstateRepr = u64;
+    const CHECKSUM_LENGTH: usize = 12;
+    const GENERATOR_SH: [u64; 5] = [
+        0x7d_52fb_a40b_d886,
+        0x5e_8dbf_1a03_950c,
+        0x1c_3a3c_7407_2a18,
+        0x38_5d72_fa0e_5139,
+        0x70_93e5_a608_865b,
+    ];
+    const TARGET_RESIDUE: u64 = 0x455_972a_3350_f7a1;
+
+    const CODE_LENGTH: usize = 1024;
+}
diff --git a/src/blind.rs b/src/blind.rs
index 6fb7ce85..65ae360e 100644
--- a/src/blind.rs
+++ b/src/blind.rs
@@ -15,6 +15,7 @@
 //! # Transactions Blinding
 //!
 
+use internals::slice::SliceExt;
 use std::{self, collections::BTreeMap, fmt};
 
 use secp256k1_zkp::{
@@ -22,17 +23,15 @@ use secp256k1_zkp::{
     rand::{CryptoRng, RngCore},
     PedersenCommitment, SecretKey, Tag, Tweak, Verification, ZERO_TWEAK,
 };
-use secp256k1_zkp::{Generator, RangeProof, Secp256k1, Signing, SurjectionProof};
+use secp256k1_zkp::{Generator, Secp256k1, Signing};
 
-use crate::{AddressParams, Script, TxIn};
+use crate::{AddressParams, RangeProof, Script, TxIn, SurjectionProof};
 
 use crate::{
     confidential::{Asset, AssetBlindingFactor, Nonce, Value, ValueBlindingFactor},
     Address, AssetId, Transaction, TxOut, TxOutWitness,
 };
 
-use crate::hashes;
-
 /// Transaction Output related errors
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TxOutError {
@@ -40,8 +39,6 @@ pub enum TxOutError {
     UnExpectedNullValue,
     /// Unexpected Null asset
     UnExpectedNullAsset,
-    /// Money should be between 0 and 21_000_000
-    MoneyOutofRange,
     /// Zero value explicit txout with non-provably unspendable script
     NonUnspendableZeroValue,
     /// Zero value pedersen commitment with provably unspendable script
@@ -57,11 +54,6 @@ impl fmt::Display for TxOutError {
         match self {
             TxOutError::UnExpectedNullValue => write!(f, "UnExpected Null Value"),
             TxOutError::UnExpectedNullAsset => write!(f, "UnExpected Null Asset"),
-            TxOutError::MoneyOutofRange => write!(
-                f,
-                "Explicit amount must be\
-                less than 21 million"
-            ),
             TxOutError::NonUnspendableZeroValue => {
                 write!(
                     f,
@@ -91,7 +83,7 @@ pub enum VerificationError {
     RangeProofError(usize, secp256k1_zkp::Error),
     /// Missing Range Proof
     RangeProofMissing(usize),
-    /// Verification of SurjectionProof failed
+    /// Verification of `SurjectionProof` failed
     SurjectionProofError(usize, secp256k1_zkp::Error),
     /// Surjection Proof verification error
     SurjectionProofVerificationError(usize),
@@ -166,7 +158,7 @@ pub enum ConfidentialTxOutError {
     NoBlindingKeyInAddress,
     /// Error originated in `secp256k1_zkp`.
     Upstream(secp256k1_zkp::Error),
-    /// General TxOut errors
+    /// General `TxOut` errors
     TxOutError(usize, TxOutError),
     /// Expected Explicit Asset for blinding
     ExpectedExplicitAsset,
@@ -208,29 +200,150 @@ impl From<secp256k1_zkp::Error> for ConfidentialTxOutError {
         ConfidentialTxOutError::Upstream(from)
     }
 }
-/// The Rangeproof message
-#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct RangeProofMessage {
-    /// The asset id
-    pub asset: AssetId,
-    /// The asset blinding factor
-    pub bf: AssetBlindingFactor,
-}
 
-impl RangeProofMessage {
-    /// Converts the message to bytes
-    pub fn to_bytes(&self) -> [u8; 64] {
-        let mut message = [0u8; 64];
+mod range_proof_message {
+    use core::fmt;
+    use internals::array::ArrayExt;
+    use secp256k1_zkp::{Generator, Signing, Secp256k1};
+    use super::{Asset, AssetId, AssetBlindingFactor};
+
+    /// The Rangeproof message
+    #[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
+    pub struct RangeProofMessage {
+        /// The asset id
+        asset_id: AssetId,
+        /// The asset blinding factor
+        asset_bf: AssetBlindingFactor,
+    }
+
+    impl RangeProofMessage {
+        /// Constructs a [`RangeProofMessage`] from an asset ID and blinding factor.
+        pub fn new(asset_id: AssetId, asset_bf: AssetBlindingFactor) -> Self {
+            Self { asset_id, asset_bf }
+        }
 
-        message[..32].copy_from_slice(self.asset.into_tag().as_ref());
-        message[32..].copy_from_slice(self.bf.into_inner().as_ref());
+        /// The asset ID embedded in the rangeproof message.
+        pub fn asset_id(&self) -> &AssetId {
+            &self.asset_id
+        }
+
+        /// The asset blinding factor embedded in the rangeproof message.
+        pub fn blinding_factor(&self) -> &AssetBlindingFactor {
+            &self.asset_bf
+        }
+
+        /// Computes the commmitment of the rangeproof message.
+        pub fn commitment<C: Signing>(&self, secp: &Secp256k1<C>) -> Generator {
+            Generator::new_blinded(secp, self.asset_id.into_tag(), self.asset_bf.into_inner())
+        }
+
+        /// Parses a message from bytes
+        pub fn from_byte_array<C: Signing>(
+            secp: &Secp256k1<C>,
+            inner: [u8; 64],
+            expected_asset: &Asset,
+        ) -> Result<Self, RangeProofMessageError> {
+            let (asset_id, asset_bf) = inner.split_array::<32, 32>();
+            let ret = Self {
+                asset_id: AssetId::from_byte_array(*asset_id),
+                asset_bf: AssetBlindingFactor::from_byte_array(*asset_bf)
+                    .map_err(RangeProofMessageError::BlindingFactorOutOfRange)?,
+            };
+
+            match expected_asset {
+                Asset::Null => return Err(RangeProofMessageError::NullExpectedAsset),
+                Asset::Explicit(asset_id) => {
+                    if ret.asset_id != *asset_id {
+                        return Err(RangeProofMessageError::ExplicitAssetMismatch {
+                            in_txout: *asset_id,
+                            in_message: ret.asset_id,
+                        })
+                    }
+                    if ret.asset_bf != AssetBlindingFactor::zero() {
+                        return Err(RangeProofMessageError::ExplicitAssetNonzeroBf {
+                            blinding_factor: ret.asset_bf,
+                        });
+                    }
+                }
+                Asset::Confidential(commitment) => {
+                    let ret_commitment = ret.commitment(secp);
+                    if ret_commitment != *commitment {
+                        return Err(RangeProofMessageError::ConfidentialAssetMismatch {
+                            in_txout: *commitment,
+                            in_message: ret_commitment,
+                        })
+                    }
+                }
+            }
+            
+            Ok(ret)
+        }
+        
+        /// Converts the message to bytes
+        pub fn to_byte_array(&self) -> [u8; 64] {
+            let mut message = [0u8; 64];
+            message[..32].copy_from_slice(self.asset_id.into_tag().as_ref());
+            message[32..].copy_from_slice(self.asset_bf.into_inner().as_ref());
+            message
+        }
+    }
+
+    #[non_exhaustive]
+    #[derive(PartialEq, Eq, Clone, Debug)]
+    pub enum RangeProofMessageError {
+        NullExpectedAsset,
+        ExplicitAssetMismatch {
+            in_txout: AssetId,
+            in_message: AssetId,
+        },
+        ExplicitAssetNonzeroBf {
+            blinding_factor: AssetBlindingFactor,
+        },
+        ConfidentialAssetMismatch {
+            in_txout: Generator,
+            in_message: Generator,
+        },
+        BlindingFactorOutOfRange(secp256k1_zkp::Error),
+    }
+
+    impl fmt::Display for RangeProofMessageError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            match *self {
+                Self::NullExpectedAsset => f.write_str("rangeproof associated with null asset"),
+                Self::ExplicitAssetMismatch { in_txout, in_message } => {
+                    write!(f, "txout had explicit asset ID {in_txout}, but rangeproof encoded asset ID {in_message}")
+                }
+                Self::ExplicitAssetNonzeroBf { blinding_factor } => {
+                    write!(f, "txout had explicit asset ID, but rangeproof encoded a nonzero asset blinding factor {blinding_factor}")
+                }
+                Self::ConfidentialAssetMismatch { in_txout, in_message } => {
+                    write!(f, "txout had asset commitment {in_txout}, but rangeproof encoded asset commitment {in_message}")
+                }
+                Self::BlindingFactorOutOfRange(ref e) => e.fmt(f),
+            }
+        }
+    }
 
-        message
+    impl std::error::Error for RangeProofMessageError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match *self {
+                Self::NullExpectedAsset => None,
+                Self::ExplicitAssetMismatch { .. } => None,
+                Self::ExplicitAssetNonzeroBf { .. } => None,
+                Self::ConfidentialAssetMismatch { .. } => None,
+                Self::BlindingFactorOutOfRange(ref e) => Some(e),
+            }
+            
+        }
     }
 }
+pub use self::range_proof_message::{RangeProofMessage, RangeProofMessageError};
 
 /// Information about Transaction Input Asset
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct TxOutSecrets {
     /// Asset
@@ -259,8 +372,9 @@ impl TxOutSecrets {
         }
     }
 
-    /// Gets the surjection inputs from [`TxOutSecrets`]
-    /// Returns a tuple (assetid, blind_factor, generator) if the blinds are
+    /// Gets the surjection inputs from [`TxOutSecrets`].
+    ///
+    /// Returns a tuple `(assetid, blind_factor, generator)` if the blinds are
     /// consistent with asset commitment
     /// Otherwise, returns an error
     pub fn surjection_inputs<C: Signing>(&self, secp: &Secp256k1<C>) -> (Generator, Tag, Tweak) {
@@ -272,11 +386,12 @@ impl TxOutSecrets {
 
     /// Gets the required fields for last value blinding factor calculation from [`TxOutSecrets`]
     pub fn value_blind_inputs(&self) -> (u64, AssetBlindingFactor, ValueBlindingFactor) {
-        return (self.value, self.asset_bf, self.value_bf);
+        (self.value, self.asset_bf, self.value_bf)
     }
 }
 
 /// Data structure used to provide inputs to [`SurjectionProof`] methods.
+///
 /// Inputs for which we don't know the secrets can be [`SurjectionInput::Unknown`],
 /// while inputs from user's wallet should be [`SurjectionInput::Known`]
 ///
@@ -322,7 +437,7 @@ impl SurjectionInput {
     }
 
     /// Handy method to convert [`SurjectionInput`] into a surjection target
-    /// that can be used while creating a new [SurjectionProof].
+    /// that can be used while creating a new [`SurjectionProof`].
     ///
     /// Only errors when the input asset is Null.
     pub fn surjection_target<C: Signing>(
@@ -382,13 +497,7 @@ impl Asset {
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let surjection_proof = SurjectionProof::new(
-            secp,
-            rng,
-            asset.into_tag(),
-            asset_bf.into_inner(),
-            inputs.as_ref(),
-        )?;
+        let surjection_proof = SurjectionProof::new(secp, rng, asset, asset_bf, inputs)?;
 
         Ok((out_asset, surjection_proof))
     }
@@ -400,8 +509,8 @@ impl Value {
     ///
     /// # Returns:
     ///
-    /// A pair of blinded asset, nonce and corresponding proof as ([`Value`], [`Nonce`], [`RangeProof`])
-    /// The nonce here refers to public key corresponding to the input `ephemeral_sk`
+    /// * A pair of blinded value, nonce and corresponding proof as ([`Value`], [`Nonce`], [`RangeProof`])
+    /// * The nonce here refers to public key corresponding to the input `ephemeral_sk`
     pub fn blind<C: Signing>(
         self,
         secp: &Secp256k1<C>,
@@ -419,7 +528,8 @@ impl Value {
         Ok((value_commit, nonce, rangeproof))
     }
 
-    /// Blinds with the given shared_secret(instead of computing it via ECDH)
+    /// Blinds with the given `shared_secret` (instead of computing it via ECDH).
+    ///
     /// This is useful while blinding assets as there is no counter party to provide
     /// the blinding key.
     pub fn blind_with_shared_secret<C: Signing>(
@@ -433,8 +543,7 @@ impl Value {
         let value = self
             .explicit()
             .ok_or(ConfidentialTxOutError::ExpectedExplicitValue)?;
-        let out_asset_commitment =
-            Generator::new_blinded(secp, msg.asset.into_tag(), msg.bf.into_inner());
+        let out_asset_commitment = msg.commitment(secp);
         let value_commitment = Value::new_confidential(secp, value, out_asset_commitment, vbf);
 
         let rangeproof = RangeProof::new(
@@ -443,7 +552,7 @@ impl Value {
             value_commitment.commitment().expect("confidential value"),
             value,
             vbf.into_inner(),
-            &msg.to_bytes(),
+            &msg.to_byte_array(),
             spk.as_bytes(),
             shared_secret,
             TxOut::RANGEPROOF_EXP_SHIFT,
@@ -461,15 +570,13 @@ impl TxOut {
     pub const RANGEPROOF_EXP_SHIFT: i32 = 0;
     /// Rangeproof Minimum private bits
     pub const RANGEPROOF_MIN_PRIV_BITS: u8 = 52;
-    /// Maximum explicit amount in a bitcoin TxOut
-    pub const MAX_MONEY: u64 = 21_000_000 * 100_000_000;
 
     /// Creates a new confidential output that is **not** the last one in the transaction.
     /// Provide input secret information by creating [`SurjectionInput`] for each input.
     /// Inputs for issuances must be provided in the followed by inputs for input asset.
     ///
     /// For example, if the second input contains non-null issuance and re-issuance tokens,
-    /// the `spent_utxo_secrets` should be of the form [inp_1, inp_2, inp_2_issue, inp2_reissue,...]
+    /// the `spent_utxo_secrets` should be of the form [`inp_1`, `inp_2`, `inp_2_issue`, `inp2_reissue`,...]
     ///
     /// If the issuance or re-issuance is null, it should not be added to `spent_utxo_secrets`
     ///
@@ -481,7 +588,7 @@ impl TxOut {
         rng: &mut R,
         secp: &Secp256k1<C>,
         value: u64,
-        address: Address,
+        address: &Address,
         asset: AssetId,
         spent_utxo_secrets: &[S],
     ) -> Result<(Self, AssetBlindingFactor, ValueBlindingFactor, SecretKey), ConfidentialTxOutError>
@@ -539,12 +646,12 @@ impl TxOut {
         let (out_asset, surjection_proof) =
             exp_asset.blind(rng, secp, out_secrets.asset_bf, spent_utxo_secrets)?;
 
-        let msg = RangeProofMessage {
-            asset: out_secrets.asset,
-            bf: out_secrets.asset_bf,
-        };
+        let msg = RangeProofMessage::new(
+            out_secrets.asset,
+            out_secrets.asset_bf,
+        );
         let exp_value = Value::Explicit(out_secrets.value);
-        let (out_value, nonce, range_proof) = exp_value.blind(
+        let (out_value, nonce, rangeproof) = exp_value.blind(
             secp,
             out_secrets.value_bf,
             receiver_blinding_pk,
@@ -559,14 +666,14 @@ impl TxOut {
             nonce,
             script_pubkey: spk,
             witness: TxOutWitness {
-                surjection_proof: Some(Box::new(surjection_proof)),
-                rangeproof: Some(Box::new(range_proof)),
+                surjection_proof,
+                rangeproof,
             },
         };
         Ok(txout)
     }
 
-    /// Convert a explicit TxOut into a Confidential TxOut.
+    /// Convert a explicit `TxOut` into a Confidential `TxOut`.
     /// The blinding key is provided by the blinder parameter.
     /// The initial value of nonce is ignored and is set to the ECDH pubkey
     /// sampled by the sender.
@@ -593,7 +700,7 @@ impl TxOut {
             self.value
                 .explicit()
                 .ok_or(ConfidentialTxOutError::ExpectedExplicitValue)?,
-            Address::from_script(&self.script_pubkey, Some(blinder), &AddressParams::ELEMENTS)
+            &Address::from_script(&self.script_pubkey, Some(blinder), &AddressParams::ELEMENTS)
                 .ok_or(ConfidentialTxOutError::InvalidAddress)?,
             self.asset
                 .explicit()
@@ -623,19 +730,15 @@ impl TxOut {
         // Only error is Null error which is dealt with later
         // when we have more context information about it.
         match self.value {
-            Value::Null => return Err(TxOutError::UnExpectedNullValue),
+            Value::Null => Err(TxOutError::UnExpectedNullValue),
             Value::Explicit(value) => {
-                if value > Self::MAX_MONEY {
-                    return Err(TxOutError::MoneyOutofRange);
-                }
                 if value == 0 {
                     // zero values are only allowed if they are provably
                     // unspendable.
                     if self.script_pubkey.is_provably_unspendable() {
                         return Err(TxOutError::ZeroValueCommitment);
-                    } else {
-                        return Err(TxOutError::NonUnspendableZeroValue);
                     }
+                    return Err(TxOutError::NonUnspendableZeroValue);
                 }
                 let asset_comm = self.get_asset_gen(secp)?;
                 Ok(PedersenCommitment::new_unblinded(secp, value, asset_comm))
@@ -648,13 +751,14 @@ impl TxOut {
     ///
     /// Inputs for issuances must be provided in the followed by inputs for input asset.
     /// For example, if the second input contains non-null issuance and re-issuance tokens,
-    /// the `spent_utxo_secrets` should be of the form [inp_1, inp_2, inp_2_issue, inp2_reissue,...]
+    /// the `spent_utxo_secrets` should be of the form [`inp_1`, `inp_2`, `inp_2_issue`, `inp2_reissue`,...]
     /// If the issuance or re-issuance is null, it should not be added to `spent_utxo_secrets`
     ///
     /// # Returns:
     ///
     /// A tuple of ([`AssetBlindingFactor`], [`ValueBlindingFactor`], ephemeral secret key [`SecretKey`])
     /// sampled from the given rng
+    #[allow(clippy::too_many_arguments)]
     pub fn new_last_confidential<R, C>(
         rng: &mut R,
         secp: &Secp256k1<C>,
@@ -687,8 +791,9 @@ impl TxOut {
         Ok((txout, out_abf, out_vbf, ephemeral_sk))
     }
 
-    /// Similar to [TxOut::new_last_confidential], but allows specifying the asset blinding factor
+    /// Similar to [`TxOut::new_last_confidential`], but allows specifying the asset blinding factor
     /// and the ephemeral key. The value-blinding factor is computed adaptively
+    #[allow(clippy::too_many_arguments)]
     pub fn with_secrets_last<R, C>(
         rng: &mut R,
         secp: &Secp256k1<C>,
@@ -707,12 +812,13 @@ impl TxOut {
     {
         let value_blind_inputs = spent_utxo_secrets
             .iter()
-            .map(|utxo_sec| utxo_sec.value_blind_inputs())
+            .map(TxOutSecrets::value_blind_inputs)
             .collect::<Vec<_>>();
 
         let value_blind_outputs = output_secrets
             .iter()
-            .map(|e| e.value_blind_inputs())
+            .copied()
+            .map(TxOutSecrets::value_blind_inputs)
             .collect::<Vec<_>>();
 
         let out_vbf = ValueBlindingFactor::last(
@@ -739,14 +845,13 @@ impl TxOut {
     /// Unblinds a transaction output, if it is confidential.
     ///
     /// It returns the secret elements of the value and asset Pedersen commitments.
-    pub fn unblind<C: Verification>(
+    pub fn unblind<C: Signing + Verification>(
         &self,
         secp: &Secp256k1<C>,
         blinding_key: SecretKey,
     ) -> Result<TxOutSecrets, UnblindError> {
-        let (commitment, additional_generator) = match (self.value, self.asset) {
-            (Value::Confidential(com), Asset::Confidential(gen)) => (com, gen),
-            _ => return Err(UnblindError::NotConfidential),
+        let (Value::Confidential(commitment), Asset::Confidential(additional_generator)) = (self.value, self.asset) else {
+            return Err(UnblindError::NotConfidential);
         };
 
         let shared_secret = self
@@ -765,18 +870,22 @@ impl TxOut {
             shared_secret,
             self.script_pubkey.as_bytes(),
             additional_generator,
-        )?;
-
-        let (asset, asset_bf) = opening.message.as_ref().split_at(32);
-        let asset = AssetId::from_slice(asset)?;
-        let asset_bf = AssetBlindingFactor::from_slice(&asset_bf[..32])?;
+        ).map_err(UnblindError::Rewind)?;
 
         let value = opening.value;
         let value_bf = ValueBlindingFactor(opening.blinding_factor);
+        let asset_and_bf = SliceExt::split_first_chunk::<64>(opening.message.as_ref())
+            .ok_or(UnblindError::MissingRangeproof)?
+            .0;
+        let message = RangeProofMessage::from_byte_array(
+            secp,
+            *asset_and_bf,
+            &self.asset,
+        ).map_err(UnblindError::RangeProofMessage)?;
 
         Ok(TxOutSecrets {
-            asset,
-            asset_bf,
+            asset: *message.asset_id(),
+            asset_bf: *message.blinding_factor(),
             value,
             value_bf,
         })
@@ -785,6 +894,7 @@ impl TxOut {
 
 /// Errors encountered when unblinding `TxOut`s.
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum UnblindError {
     /// The `TxOut` is not fully confidential.
     NotConfidential,
@@ -792,18 +902,18 @@ pub enum UnblindError {
     MissingNonce,
     /// Transaction output does not have a rangeproof.
     MissingRangeproof,
-    /// Malformed asset ID.
-    MalformedAssetId(hashes::Error),
+    /// Malformed rangeproof message.
+    RangeProofMessage(RangeProofMessageError),
     /// Error originated in `secp256k1_zkp`.
-    Upstream(secp256k1_zkp::Error),
+    Rewind(secp256k1_zkp::Error),
 }
 
 impl fmt::Display for UnblindError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
             UnblindError::MissingNonce => write!(f, "missing nonce in txout"),
-            UnblindError::MalformedAssetId(_) => write!(f, "malformed asset id"),
-            UnblindError::Upstream(e) => write!(f, "{}", e),
+            UnblindError::RangeProofMessage(_) => f.write_str("failed to parse message embedded in rangeproof"),
+            UnblindError::Rewind(_) => f.write_str("failed to rewind rangeproof"),
             UnblindError::NotConfidential => write!(f, "cannot unblind non-confidential txout"),
             UnblindError::MissingRangeproof => write!(f, "missing rangeproof in txout"),
         }
@@ -814,26 +924,14 @@ impl std::error::Error for UnblindError {
     fn cause(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             UnblindError::MissingNonce => None,
-            UnblindError::MalformedAssetId(e) => Some(e),
-            UnblindError::Upstream(e) => Some(e),
+            UnblindError::RangeProofMessage(e) => Some(e),
+            UnblindError::Rewind(e) => Some(e),
             UnblindError::NotConfidential => None,
             UnblindError::MissingRangeproof => None,
         }
     }
 }
 
-impl From<secp256k1_zkp::Error> for UnblindError {
-    fn from(from: secp256k1_zkp::Error) -> Self {
-        UnblindError::Upstream(from)
-    }
-}
-
-impl From<hashes::Error> for UnblindError {
-    fn from(from: hashes::Error) -> Self {
-        UnblindError::MalformedAssetId(from)
-    }
-}
-
 impl TxIn {
     /// Blind issuances for this [`TxIn`]. Asset amount and token amount must be
     /// set in [`AssetIssuance`](crate::AssetIssuance) field for this input
@@ -866,17 +964,17 @@ impl TxIn {
                 Value::Explicit(v) => Value::Explicit(v),
             };
             let spk = Script::new();
-            let msg = RangeProofMessage {
+            let msg = RangeProofMessage::new(
                 asset,
-                bf: AssetBlindingFactor::zero(),
-            };
+                AssetBlindingFactor::zero(),
+            );
             let (comm, prf) = v.blind_with_shared_secret(secp, bf, blind_sk, &spk, &msg)?;
             if i == 0 {
                 self.asset_issuance.amount = comm;
-                self.witness.amount_rangeproof = Some(Box::new(prf));
+                self.witness.amount_rangeproof = prf;
             } else {
                 self.asset_issuance.inflation_keys = comm;
-                self.witness.inflation_keys_rangeproof = Some(Box::new(prf));
+                self.witness.inflation_keys_rangeproof = prf;
             }
         }
         Ok(())
@@ -885,7 +983,7 @@ impl TxIn {
     /// Blind issuances for this [`TxIn`]. Asset amount and token amount must be
     /// set in [`AssetIssuance`](crate::AssetIssuance) field for this input
     ///
-    /// Returns (issuance_blinding_factor, issue_blind_sec_key, token_blinding_factor, token_blind_sec_key)
+    /// Returns (`issuance_blinding_factor`, `issue_blind_sec_key`, `token_blinding_factor`, `token_blind_sec_key`)
     pub fn blind_issuances<C: Signing, R: RngCore + CryptoRng>(
         &mut self,
         secp: &Secp256k1<C>,
@@ -908,47 +1006,60 @@ impl TxIn {
     }
 }
 
-/// Data structure for Unifying inputs and pseudo-inputs.
+/// Inputs or pseudo-inputs.
 #[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub enum TxInType {
+pub enum CtLocationType {
     /// Regular input
-    Input(usize),
-    /// Issuance Pseudo-input
-    Issuance(usize),
-    /// Re-issuance pseudo-input
-    ReIssuance(usize),
+    Input,
+
+    /// Issuance pseudo-input
+    Issuance,
+
+    /// Reissuance pseudo-input
+    Reissuance,
 }
 
+/// Data structure for Unifying inputs and pseudo-inputs.
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct CtLocation {
+    /// Input index
+    pub input_index: usize,
+
+    /// Input or pseudo-input type
+    pub ty: CtLocationType,
+}
+
+
 impl Transaction {
     /// Verify that the transaction has correctly calculated blinding
     /// factors and they CT verification equation holds.
     /// This is *NOT* a complete Transaction verification check
-    /// It does *NOT* check whether input witness/script satifies
+    /// It does *NOT* check whether input witness/script satisfies
     /// the script pubkey, or inputs are double-spent and other
     /// consensus checks.
     /// This method only checks if the [Transaction] verification
     /// equation for Confidential transactions holds.
     /// i.e Sum of inputs = Sum of outputs + fees.
     /// And the corresponding surjection/rangeproofs are correct.
-    /// For checking of surjection proofs and amounts, spent_utxos parameter
+    /// For checking of surjection proofs and amounts, `spent_utxos` parameter
     /// should contain information about the prevouts. Note that the order of
-    /// spent_utxos should be consistent with transaction inputs.
+    /// `spent_utxos` should be consistent with transaction inputs.
     /// ## Examples
     ///
     /// ```
     /// # use std::str::FromStr;
-    /// # use elements::hashes::hex::FromHex;
+    /// # use elements::hex;
     /// # use elements::encode::deserialize;
     /// # use elements::secp256k1_zkp;
     /// # use elements::{confidential, script, Transaction, TxOut, TxOutWitness};
     /// # fn body() -> Result<(), Box<dyn std::error::Error>> {
     /// let secp = secp256k1_zkp::Secp256k1::new();
-    /// let tx: Transaction = deserialize(&Vec::<u8>::from_hex(
+    /// let tx: Transaction = deserialize(&hex::hex!(
     ///     "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"
-    /// ).unwrap()).unwrap();
-    /// let conf_asset : confidential::Asset = deserialize(&Vec::<u8>::from_hex("0b37d4818b8ce1df5d3d0b88d140c6848029d6d85fb0f6ee270865caf53d0b82d4").unwrap()).unwrap();
-    /// let conf_value : confidential::Value = deserialize(&Vec::<u8>::from_hex("094e2cceeb8005ac14b611821c37fca757b47426afb0bb4eabe41c275d3997c046").unwrap()).unwrap();
-    /// let spk : script::Script = deserialize(&Vec::<u8>::from_hex("16001475f578ed4f7a0103182a6e92942c66350dd949dc").unwrap()).unwrap();
+    /// )).unwrap();
+    /// let conf_asset : confidential::Asset = deserialize(&hex::hex!("0b37d4818b8ce1df5d3d0b88d140c6848029d6d85fb0f6ee270865caf53d0b82d4")).unwrap();
+    /// let conf_value : confidential::Value = deserialize(&hex::hex!("094e2cceeb8005ac14b611821c37fca757b47426afb0bb4eabe41c275d3997c046")).unwrap();
+    /// let spk : script::Script = deserialize(&hex::hex!("16001475f578ed4f7a0103182a6e92942c66350dd949dc")).unwrap();
     ///
     /// let txout = TxOut {
     ///     asset: conf_asset,
@@ -994,19 +1105,19 @@ impl Transaction {
                     (inp.asset_issuance.amount, asset_id),
                     (inp.asset_issuance.inflation_keys, token_id),
                 ];
-                for (amt, asset) in arr.iter() {
+                for (amt, asset) in &arr {
                     match amt {
-                        Value::Null => continue,
+                        Value::Null => {},
                         Value::Explicit(v) => {
                             let gen = Generator::new_unblinded(secp, asset.into_tag());
                             domain.push(gen);
                             let comm = PedersenCommitment::new_unblinded(secp, *v, gen);
-                            in_commits.push(comm)
+                            in_commits.push(comm);
                         }
                         Value::Confidential(comm) => {
                             let gen = Generator::new_unblinded(secp, asset.into_tag());
                             domain.push(gen);
-                            in_commits.push(*comm)
+                            in_commits.push(*comm);
                         }
                     }
                 }
@@ -1070,7 +1181,7 @@ impl Transaction {
         secp: &Secp256k1<C>,
         spent_utxo_secrets: &[TxOutSecrets],
         blind_issuances: bool,
-    ) -> Result<BTreeMap<TxInType, (AssetBlindingFactor, ValueBlindingFactor, SecretKey)>, BlindError>
+    ) -> Result<BTreeMap<CtLocation, (AssetBlindingFactor, ValueBlindingFactor, SecretKey)>, BlindError>
     where
         R: RngCore + CryptoRng,
         C: Signing,
@@ -1082,13 +1193,13 @@ impl Transaction {
                 let (iss_vbf, iss_sk, tkn_vbf, tkn_sk) = txin.blind_issuances(secp, rng)?;
                 if txin.asset_issuance.amount.is_confidential() {
                     blinds.insert(
-                        TxInType::Issuance(i),
+                        CtLocation{ input_index: i, ty: CtLocationType::Issuance },
                         (AssetBlindingFactor::zero(), iss_vbf, iss_sk),
                     );
                 }
                 if txin.asset_issuance.inflation_keys.is_confidential() {
                     blinds.insert(
-                        TxInType::ReIssuance(i),
+                        CtLocation{ input_index: i, ty: CtLocationType::Reissuance },
                         (AssetBlindingFactor::zero(), tkn_vbf, tkn_sk),
                     );
                 }
@@ -1131,12 +1242,13 @@ impl Transaction {
                     rng,
                     secp,
                     out.value.explicit().unwrap(),
-                    address,
+                    &address,
                     out.asset.explicit().unwrap(),
-                    &spent_utxo_secrets,
+                    spent_utxo_secrets,
                 )?;
 
-                blinds.insert(TxInType::Input(i), (abf, vbf, ephemeral_sk));
+                let location = CtLocation { input_index: i, ty: CtLocationType::Input};
+                blinds.insert(location, (abf, vbf, ephemeral_sk));
                 out_secrets.push(TxOutSecrets::new(
                     out.asset.explicit().unwrap(),
                     abf,
@@ -1176,7 +1288,8 @@ impl Transaction {
             &out_secrets,
         )?;
 
-        blinds.insert(TxInType::Input(last_index), (abf, vbf, ephemeral_sk));
+        let location = CtLocation{ input_index: last_index, ty: CtLocationType::Input };
+        blinds.insert(location, (abf, vbf, ephemeral_sk));
         self.output[last_index] = conf_out;
         Ok(blinds)
     }
@@ -1193,9 +1306,9 @@ pub enum BlindError {
     TooFewBlindingOutputs,
     /// All outputs must be explicit asset/amounts
     MustHaveAllExplicitTxOuts,
-    /// General TxOut errors
+    /// General `TxOut` errors
     ConfidentialTxOutError(ConfidentialTxOutError),
-    /// No Issuances to blind in this TxIn
+    /// No Issuances to blind in this `TxIn`
     NoIssuanceToBlind,
     /// Zero Value Blinding not allowed
     ZeroValueBlindingNotAllowed,
@@ -1246,145 +1359,29 @@ impl From<ConfidentialTxOutError> for BlindError {
     }
 }
 
-/// A trait to create and verify explicit rangeproofs
-pub trait BlindValueProofs: Sized {
-    /// Outputs a `[RangeProof]` that blinded value
-    /// corresponfs to unblinded explicit value
-    fn blind_value_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
-        rng: &mut R,
-        secp: &Secp256k1<C>,
-        explicit_val: u64,
-        value_commit: PedersenCommitment,
-        asset_gen: Generator,
-        vbf: ValueBlindingFactor,
-    ) -> Result<Self, secp256k1_zkp::Error>;
-
-    /// Verify that the Rangeproof proves that commitment
-    /// is actually bound to the explicit value
-    fn blind_value_proof_verify<C: secp256k1_zkp::Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-        explicit_val: u64,
-        asset_gen: Generator,
-        value_commit: PedersenCommitment,
-    ) -> bool;
-}
-
-impl BlindValueProofs for RangeProof {
-    /// Outputs a `[RangeProof]` that blinded value_commit
-    /// corresponds to explicit value
-    fn blind_value_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
-        rng: &mut R,
-        secp: &Secp256k1<C>,
-        explicit_val: u64,
-        value_commit: PedersenCommitment,
-        asset_gen: Generator,
-        vbf: ValueBlindingFactor,
-    ) -> Result<Self, secp256k1_zkp::Error> {
-        RangeProof::new(
-            secp,
-            explicit_val,        // min_value
-            value_commit,        // value_commit
-            explicit_val,        // value
-            vbf.into_inner(),    // blinding factor
-            &[],                 // message
-            &[],                 // add commitment
-            SecretKey::new(rng), // nonce
-            -1,                  // exp
-            0,                   // min bits
-            asset_gen,           // additional gen
-        )
-    }
-
-    /// Verify that the Rangeproof proves that commitment
-    /// is actually bound to the explicit value
-    fn blind_value_proof_verify<C: secp256k1_zkp::Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-        explicit_val: u64,
-        asset_gen: Generator,
-        value_commit: PedersenCommitment,
-    ) -> bool {
-        let r = self.verify(secp, value_commit, &[], asset_gen);
-        match r {
-            Ok(e) => e.start == explicit_val && e.end - 1 == explicit_val,
-            Err(..) => return false,
-        }
-    }
-}
-
-/// A trait to create and verify explicit surjection proofs
-pub trait BlindAssetProofs: Sized {
-    /// Outputs a `[SurjectionProof]` that blinded asset
-    /// corresponfs to unblinded explicit asset
-    fn blind_asset_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
-        rng: &mut R,
-        secp: &Secp256k1<C>,
-        asset: AssetId,
-        abf: AssetBlindingFactor,
-    ) -> Result<Self, secp256k1_zkp::Error>;
-
-    /// Verify that the Surjection proves that asset commitment
-    /// is actually bound to the explicit asset
-    fn blind_asset_proof_verify(
-        &self,
-        secp: &Secp256k1<secp256k1_zkp::All>,
-        asset: AssetId,
-        asset_commit: Generator,
-    ) -> bool;
-}
-
-impl BlindAssetProofs for SurjectionProof {
-    fn blind_asset_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
-        rng: &mut R,
-        secp: &Secp256k1<C>,
-        asset: AssetId,
-        abf: AssetBlindingFactor,
-    ) -> Result<Self, secp256k1_zkp::Error> {
-        let gen = Generator::new_unblinded(secp, asset.into_tag());
-        SurjectionProof::new(
-            secp,
-            rng,
-            asset.into_tag(),
-            abf.into_inner(),
-            &[(gen, asset.into_tag(), ZERO_TWEAK)],
-        )
-    }
-
-    fn blind_asset_proof_verify(
-        &self,
-        secp: &Secp256k1<secp256k1_zkp::All>,
-        asset: AssetId,
-        asset_commit: Generator,
-    ) -> bool {
-        let gen = Generator::new_unblinded(secp, asset.into_tag());
-        self.verify(secp, asset_commit, &[gen])
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::confidential;
     use crate::encode;
     use crate::encode::deserialize;
-    use crate::hashes::hex::FromHex;
     use crate::Script;
-    use bitcoin::{self, Network, PrivateKey, PublicKey};
+    use bitcoin::{PrivateKey, PublicKey};
     use rand::thread_rng;
     use secp256k1_zkp::SECP256K1;
+    use std::str::FromStr;
 
     #[test]
     fn test_blind_tx() {
         // tested with elements 0.20 rebase branch
-        let tx_hex = "020000000001741498f6da8f47eb438d0fb9de099b7e29c0e011b9ab64c3e0eb097a09a6a9220100000000fdffffff0301230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b201000775f04dedb2d102a11e47fd7a0edfb424a43b2d3cf29d700d4b168c92e115709ff7d15070e201dd16001483641e58db3de6067f010d71c9782874572af9fb01230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20100000000000f42400206a1039b0fe0d110d2108f2cc49d637f95b6ac18045af5b302b3c14bf8457994160014ad65ebbed8416659141cc788c1b917d6ff3e059901230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20100000000000000f9000000000000";
-        let mut tx: Transaction = deserialize(&Vec::<u8>::from_hex(tx_hex).unwrap()[..]).unwrap();
+        const TX_HEX: &str = "020000000001741498f6da8f47eb438d0fb9de099b7e29c0e011b9ab64c3e0eb097a09a6a9220100000000fdffffff0301230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b201000775f04dedb2d102a11e47fd7a0edfb424a43b2d3cf29d700d4b168c92e115709ff7d15070e201dd16001483641e58db3de6067f010d71c9782874572af9fb01230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20100000000000f42400206a1039b0fe0d110d2108f2cc49d637f95b6ac18045af5b302b3c14bf8457994160014ad65ebbed8416659141cc788c1b917d6ff3e059901230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20100000000000000f9000000000000";
+        let mut tx: Transaction = deserialize(&hex::hex!(TX_HEX)).unwrap();
         let spent_utxo_secrets = TxOutSecrets {
-            asset: AssetId::from_hex(
+            asset: AssetId::from_str(
                 "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23",
             )
             .unwrap(),
-            asset_bf: AssetBlindingFactor::from_hex(
+            asset_bf: AssetBlindingFactor::from_str(
                 "a5b3d111cdaa5fc111e2723df4caf315864f25fb4610cc737f10d5a55cd4096f",
             )
             .unwrap(),
@@ -1394,7 +1391,7 @@ mod tests {
             )
             .unwrap()
             .to_sat(),
-            value_bf: ValueBlindingFactor::from_hex(
+            value_bf: ValueBlindingFactor::from_str(
                 "e36a4de359469f547571d117bc5509fb74fba73c84b0cdd6f4edfa7ff7fa457d",
             )
             .unwrap(),
@@ -1423,27 +1420,18 @@ mod tests {
 
         let spent_utxo = TxOut {
             asset: Asset::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "0baf634b18e1880c96dcf9947b0e0fd2d38d66d723339174df3fd980148c2f0bb3",
-                )
-                .unwrap(),
+                &hex::hex!("0baf634b18e1880c96dcf9947b0e0fd2d38d66d723339174df3fd980148c2f0bb3"),
             )
             .unwrap(),
             value: Value::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "093baba9076190867fbc5e43132cb2f82245caf603b493d7c0da8b7eda7912fa2c",
-                )
-                .unwrap(),
+                &hex::hex!("093baba9076190867fbc5e43132cb2f82245caf603b493d7c0da8b7eda7912fa2c"),
             )
             .unwrap(),
             nonce: Nonce::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "02a96a456f4936dcf0afbc325ac3798c4464e7b66dd460d564f3f91882d6089a3b",
-                )
-                .unwrap(),
+                &hex::hex!("02a96a456f4936dcf0afbc325ac3798c4464e7b66dd460d564f3f91882d6089a3b"),
             )
             .unwrap(),
-            script_pubkey: Script::from_hex("0014d2bcde17e7744f6377466ca1bd35d212954674c8")
+            script_pubkey: Script::from_hex_no_prefix("0014d2bcde17e7744f6377466ca1bd35d212954674c8")
                 .unwrap(),
             witness: TxOutWitness::default(),
         };
@@ -1457,19 +1445,19 @@ mod tests {
         let (address, blinding_sk) = {
             let sk = SecretKey::new(&mut thread_rng());
             let pk = PublicKey::from_private_key(
-                &SECP256K1,
+                SECP256K1,
                 &PrivateKey {
                     compressed: true,
-                    network: Network::Regtest,
+                    network: bitcoin::NetworkKind::Test,
                     inner: sk,
                 },
             );
             let blinding_sk = SecretKey::new(&mut thread_rng());
             let blinding_pk = PublicKey::from_private_key(
-                &SECP256K1,
+                SECP256K1,
                 &PrivateKey {
                     compressed: true,
-                    network: Network::Regtest,
+                    network: bitcoin::NetworkKind::Test,
                     inner: blinding_sk,
                 },
             );
@@ -1501,7 +1489,7 @@ mod tests {
             &mut thread_rng(),
             SECP256K1,
             value,
-            address,
+            &address,
             asset,
             &spent_utxo_secrets,
         )
@@ -1515,7 +1503,7 @@ mod tests {
 
     #[test]
     fn blind_value_proof_test() {
-        let id = AssetId::from_slice(&[1u8; 32]).unwrap();
+        let id = AssetId::from_byte_array([1u8; 32]);
         let abf = AssetBlindingFactor::new(&mut thread_rng());
         let asset = confidential::Asset::new_confidential(SECP256K1, id, abf);
 
@@ -1541,7 +1529,7 @@ mod tests {
 
     #[test]
     fn blind_asset_proof_test() {
-        let id = AssetId::from_slice(&[1u8; 32]).unwrap();
+        let id = AssetId::from_byte_array([1u8; 32]);
         let abf = AssetBlindingFactor::new(&mut thread_rng());
         let asset = confidential::Asset::new_confidential(SECP256K1, id, abf);
 
@@ -1560,7 +1548,7 @@ mod tests {
         let secp = secp256k1_zkp::Secp256k1::new();
         let tx_str = include_str!("../tests/data/issue_tx.hex");
 
-        let bytes = Vec::<u8>::from_hex(tx_str).unwrap();
+        let bytes = hex::decode_to_vec(tx_str).unwrap();
         let tx = encode::deserialize::<Transaction>(&bytes).unwrap();
 
         let mut utxos = [
@@ -1571,50 +1559,32 @@ mod tests {
         ];
         {
             utxos[0].asset = Asset::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "0ae7a52e8e4b07e00548bab151a83e5c9ab2f9a910e10dcee930a1a152a939f99e",
-                )
-                .unwrap(),
+                &hex::hex!("0ae7a52e8e4b07e00548bab151a83e5c9ab2f9a910e10dcee930a1a152a939f99e"),
             )
             .unwrap();
             utxos[0].value = Value::Explicit(1);
 
             utxos[1].asset = Asset::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "0bc226167e9ee0bb5a86c8f1478ee7d7becb7bfd4d97c26a041e628c5486a8c67a",
-                )
-                .unwrap(),
+                &hex::hex!("0bc226167e9ee0bb5a86c8f1478ee7d7becb7bfd4d97c26a041e628c5486a8c67a"),
             )
             .unwrap();
             utxos[1].value = Value::Explicit(1);
 
             utxos[2].asset = Asset::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "0b495dbfc356993c5ac157c3d04fadf6f198a7e35a873df482ad9e4e95daa8aa7e",
-                )
-                .unwrap(),
+                &hex::hex!("0b495dbfc356993c5ac157c3d04fadf6f198a7e35a873df482ad9e4e95daa8aa7e"),
             )
             .unwrap();
             utxos[2].value = Value::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "08e0ac2ab5f3c173d5e0652a2ec209a9a370a4e510178e73c2f22f9e132341abf4",
-                )
-                .unwrap(),
+                &hex::hex!("08e0ac2ab5f3c173d5e0652a2ec209a9a370a4e510178e73c2f22f9e132341abf4"),
             )
             .unwrap();
 
             utxos[3].asset = Asset::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "0aa0956d60687982d5e73d52f8c5902478754e5f0e2e5ceff5ae53fa9681c12ae1",
-                )
-                .unwrap(),
+                &hex::hex!("0aa0956d60687982d5e73d52f8c5902478754e5f0e2e5ceff5ae53fa9681c12ae1"),
             )
             .unwrap();
             utxos[3].value = Value::from_commitment(
-                &Vec::<u8>::from_hex(
-                    "094b35f1e86b097ccf0b3a826570c089c724ed9cf22620937500b14acdd169e7bf",
-                )
-                .unwrap(),
+                &hex::hex!("094b35f1e86b097ccf0b3a826570c089c724ed9cf22620937500b14acdd169e7bf"),
             )
             .unwrap();
         }
diff --git a/src/block.rs b/src/block.rs
index cdf2efe2..c2153b33 100644
--- a/src/block.rs
+++ b/src/block.rs
@@ -17,14 +17,19 @@
 
 use std::io;
 
-use bitcoin::hashes::{Hash, sha256};
 #[cfg(feature = "serde")] use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "serde")] use std::fmt;
 
 use crate::dynafed;
+use crate::hashes::{HashEngine as _, sha256d};
 use crate::Transaction;
-use crate::encode::{self, Encodable, Decodable, serialize};
-use crate::{BlockHash, Script, TxMerkleNode, VarInt};
+use crate::encode::{self, serialize, Decodable, Encodable, VarInt};
+use crate::{BlockHash, Script, TxMerkleNode};
+
+impl_sha256_midstate_wrapper! {
+    /// The Merkle root of a set of dynafed parameters.
+    pub struct DynafedRoot([u8; 32]);
+}
 
 /// Data related to block signatures
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -55,7 +60,7 @@ impl<'de> Deserialize<'de> for ExtData {
         enum Enum { Unknown, Challenge, Solution, Current, Proposed, Witness }
         struct EnumVisitor;
 
-        impl<'de> de::Visitor<'de> for EnumVisitor {
+        impl de::Visitor<'_> for EnumVisitor {
             type Value = Enum;
 
             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -230,7 +235,7 @@ impl BlockHeader {
         };
 
         // Everything except the signblock witness goes into the hash
-        let mut enc = BlockHash::engine();
+        let mut enc = sha256d::Hash::engine();
         version.consensus_encode(&mut enc).unwrap();
         self.prev_blockhash.consensus_encode(&mut enc).unwrap();
         self.merkle_root.consensus_encode(&mut enc).unwrap();
@@ -245,19 +250,12 @@ impl BlockHeader {
                 proposed.consensus_encode(&mut enc).unwrap();
             },
         }
-        BlockHash::from_engine(enc)
+        BlockHash(enc.finalize())
     }
 
     /// Returns true if this is a block with dynamic federations enabled.
     pub fn is_dynafed(&self) -> bool {
-        if let ExtData::Dynafed {
-            ..
-        } = self.ext
-        {
-            true
-        } else {
-            false
-        }
+        matches!(self.ext, ExtData::Dynafed { .. })
     }
 
     /// Remove the witness data of the block header.
@@ -275,15 +273,15 @@ impl BlockHeader {
     }
 
     /// Calculate the root of the dynafed params. Returns [None] when not dynafed.
-    pub fn calculate_dynafed_params_root(&self) -> Option<sha256::Midstate> {
+    pub fn calculate_dynafed_params_root(&self) -> Option<crate::DynafedRoot> {
         match self.ext {
             ExtData::Proof { .. } => None,
             ExtData::Dynafed { ref current, ref proposed, .. } => {
                 let leaves = [
-                    current.calculate_root().into_inner(),
-                    proposed.calculate_root().into_inner(),
+                    current.calculate_root().to_byte_array(),
+                    proposed.calculate_root().to_byte_array(),
                 ];
-                Some(crate::fast_merkle_root::fast_merkle_root(&leaves[..]))
+                Some(DynafedRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..])))
             }
         }
     }
@@ -362,7 +360,6 @@ pub struct Block {
     /// Complete list of transaction in the block
     pub txdata: Vec<Transaction>,
 }
-serde_struct_impl!(Block, header, txdata);
 impl_consensus_encoding!(Block, header, txdata);
 
 impl Block {
@@ -380,7 +377,7 @@ impl Block {
     /// Get the size of the block
     pub fn size(&self) -> usize {
         // The size of the header + the size of the varint with the tx count + the txs themselves
-        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len() as u64).len();
+        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size();
         let txs_size: usize = self.txdata.iter().map(Transaction::size).sum();
         base_size + txs_size
     }
@@ -393,7 +390,7 @@ impl Block {
 
     /// Get the weight of the block
     pub fn weight(&self) -> usize {
-        let base_weight = 4 * (serialize(&self.header).len() + VarInt(self.txdata.len() as u64).len());
+        let base_weight = 4 * (serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size());
         let txs_weight: usize = self.txdata.iter().map(Transaction::weight).sum();
         base_weight + txs_weight
     }
@@ -402,11 +399,10 @@ impl Block {
 #[cfg(test)]
 mod tests {
     use crate::Block;
-    use crate::hashes::hex::FromHex;
 
     use super::*;
 
-    const SIMPLE_BLOCK: &'static str = "\
+    const SIMPLE_BLOCK: &str = "\
              00000020a66e4a4baff69735267346d12e59e8a0da848b593813554deb16a6f3\
              6cd035e9aab0e2451724598471dd4e45f0dca40ca5f4ac62e61957e50925af08\
              59891fcc8842805b020000000151000102000000010100000000000000000000\
@@ -418,7 +414,7 @@ mod tests {
              7d45000000000000012000000000000000000000000000000000000000000000\
              000000000000000000000000000000\
              ";
-    const DYNAFED_BLOCK: &'static str = "\
+    const DYNAFED_BLOCK: &str = "\
             000000a0da9d569617d1d65c3390a01c18c4fa7c4d0f4738b6fc2b5c5faf2e8a\
             463abbaa46eb9123808e1e2ff75e9472fa0f0589b53b7518a69d3d6fcb9228ed\
             345734ea06b9c45d070000000122002057c555a91edf9552282d88624d1473c2\
@@ -441,7 +437,7 @@ mod tests {
             000000000000000000000000000000000000\
             ";
 
-    #[cfg(feature = "serde-feature")]
+    #[cfg(feature = "serde")]
     #[test]
     fn blockheader_serde() {
         let block: Block = hex_deserialize!(&SIMPLE_BLOCK);
@@ -449,7 +445,7 @@ mod tests {
         let block: Block = hex_deserialize!(&DYNAFED_BLOCK);
         roundtrip_header(&block.header);
     }
-    #[cfg(feature = "serde-feature")]
+    #[cfg(feature = "serde")]
     fn roundtrip_header(header: &BlockHeader) {
         let header_ser = serde_json::to_string(header).unwrap();
         let header_deser: BlockHeader = serde_json::from_str(&header_ser).unwrap();
@@ -470,7 +466,7 @@ mod tests {
             block.block_hash().to_string(),
             "287ca47e8da47eb8c28d870663450bb026922eadb30a1b2f8293e6e9d1ca5322"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 2);
         assert_eq!(block.txdata.len(), 1);
         assert_eq!(block.size(), serialize(&block).len());
@@ -682,7 +678,7 @@ mod tests {
             block.block_hash().to_string(),
             "e935d06cf3a616eb4d551338598b84daa0e8592ed14673263597f6af4b4a6ea6"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 1);
         assert_eq!(block.txdata.len(), 3);
         assert_eq!(block.size(), serialize(&block).len());
@@ -713,7 +709,7 @@ mod tests {
             block.block_hash().to_string(),
             "bcc6eb2ab6c97b9b4590825b9136f100b22e090c0469818572b8b93926a79f28"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
         if let ExtData::Proof { challenge, solution } = block.header.ext {
             assert_eq!(challenge.len(), 1 + 3 * 34 + 2);
             assert_eq!(solution.len(), 144);
@@ -734,7 +730,7 @@ mod tests {
             } else {
                 panic!("Current block dynafed params not compact");
             }
-            if let dynafed::Params::Null { .. } = proposed {
+            if let dynafed::Params::Null = proposed {
                 /* pass */
             } else {
                 panic!("Proposed block dynafed params not compact");
@@ -747,7 +743,7 @@ mod tests {
             block.block_hash().to_string(),
             "4961df970cf12d789383974e6ab439f780d956b5a50162ca9d281362e46c605a"
         );
-        assert_eq!(block.header.version, 0x20000000);
+        assert_eq!(block.header.version, 0x2000_0000);
 
         // Full current and proposal
         let block: Block = hex_deserialize!("\
@@ -803,7 +799,7 @@ mod tests {
     fn test_failed_block() {
         let block_str = include_str!("../tests/data/failedblock.hex");
 
-        let bytes = Vec::<u8>::from_hex(block_str).unwrap();
+        let bytes = hex::decode_to_vec(block_str).unwrap();
         let _block = encode::deserialize::<Block>(&bytes).unwrap();
     }
 }
diff --git a/src/confidential.rs b/src/confidential.rs
deleted file mode 100644
index 0116c736..00000000
--- a/src/confidential.rs
+++ /dev/null
@@ -1,1454 +0,0 @@
-// Rust Elements Library
-// Written in 2018 by
-//   Andrew Poelstra <apoelstra@blockstream.com>
-//
-// To the extent possible under law, the author(s) have dedicated all
-// copyright and related and neighboring rights to this software to
-// the public domain worldwide. This software is distributed without
-// any warranty.
-//
-// You should have received a copy of the CC0 Public Domain Dedication
-// along with this software.
-// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
-//
-
-//! # Confidential Commitments
-//!
-//! Structures representing Pedersen commitments of various types
-//!
-
-use crate::hashes::{sha256d, Hash, hex};
-use secp256k1_zkp::{self, CommitmentSecrets, Generator, PedersenCommitment,
-    PublicKey, Secp256k1, SecretKey, Signing, Tweak, ZERO_TWEAK,
-    compute_adaptive_blinding_factor,
-    rand::{CryptoRng, Rng, RngCore}
-};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-use std::{fmt, io, ops::{AddAssign, Neg}, str};
-
-use crate::encode::{self, Decodable, Encodable};
-use crate::issuance::AssetId;
-
-/// A CT commitment to an amount
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-pub enum Value {
-    /// No value
-    Null,
-    /// Value is explicitly encoded
-    Explicit(u64),
-    /// Value is committed
-    Confidential(PedersenCommitment),
-}
-
-impl Value {
-    /// Create value commitment.
-    pub fn new_confidential<C: Signing>(
-        secp: &Secp256k1<C>,
-        value: u64,
-        asset: Generator,
-        bf: ValueBlindingFactor,
-    ) -> Self {
-        Value::Confidential(PedersenCommitment::new(secp, value, bf.0, asset))
-    }
-
-    /// Create value commitment from assetID, asset blinding factor,
-    /// value and value blinding factor
-    pub fn new_confidential_from_assetid<C: Signing>(
-        secp: &Secp256k1<C>,
-        value: u64,
-        asset: AssetId,
-        v_bf: ValueBlindingFactor,
-        a_bf: AssetBlindingFactor,
-    ) -> Self {
-        let generator = Generator::new_blinded(secp, asset.into_tag(), a_bf.0);
-        let comm = PedersenCommitment::new(secp, value, v_bf.0, generator);
-
-        Value::Confidential(comm)
-    }
-
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Value::Null => 1,
-            Value::Explicit(..) => 9,
-            Value::Confidential(..) => 33,
-        }
-    }
-
-    /// Create from commitment.
-    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
-        Ok(Value::Confidential(PedersenCommitment::from_slice(bytes)?))
-    }
-
-    /// Check if the object is null.
-    pub fn is_null(&self) -> bool {
-        match self {
-            Value::Null => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is explicit.
-    pub fn is_explicit(&self) -> bool {
-        match self {
-            Value::Explicit(_) => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is confidential.
-    pub fn is_confidential(&self) -> bool {
-        match self {
-            Value::Confidential(_) => true,
-            _ => false
-        }
-    }
-
-    /// Returns the explicit inner value.
-    /// Returns [None] if [is_explicit] returns false.
-    pub fn explicit(&self) -> Option<u64> {
-        match *self {
-            Value::Explicit(i) => Some(i),
-            _ => None,
-        }
-    }
-
-    /// Returns the confidential commitment in case of a confidential value.
-    /// Returns [None] if [is_confidential] returns false.
-    pub fn commitment(&self) -> Option<PedersenCommitment> {
-        match *self {
-            Value::Confidential(i) => Some(i),
-            _ => None,
-        }
-    }
-}
-
-impl From<PedersenCommitment> for Value {
-    fn from(from: PedersenCommitment) -> Self {
-        Value::Confidential(from)
-    }
-}
-
-impl fmt::Display for Value {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Value::Null => f.write_str("null"),
-            Value::Explicit(n) => write!(f, "{}", n),
-            Value::Confidential(commitment) => write!(f, "{:02x}", commitment),
-        }
-    }
-}
-
-impl Default for Value {
-    fn default() -> Self {
-        Value::Null
-    }
-}
-
-impl Encodable for Value {
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
-        match *self {
-            Value::Null => 0u8.consensus_encode(s),
-            Value::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + u64::swap_bytes(n).consensus_encode(&mut s)?)
-            }
-            Value::Confidential(commitment) => commitment.consensus_encode(&mut s),
-        }
-    }
-}
-
-impl Encodable for PedersenCommitment {
-    fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
-        e.write_all(&self.serialize())?;
-        Ok(33)
-    }
-}
-
-impl Decodable for Value {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Value, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
-
-        match prefix {
-            0 => Ok(Value::Null),
-            1 => {
-                let explicit = u64::swap_bytes(Decodable::consensus_decode(&mut d)?);
-                Ok(Value::Explicit(explicit))
-            }
-            p if p == 0x08 || p == 0x09 => {
-                let mut comm = [0u8; 33];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Value::Confidential(PedersenCommitment::from_slice(&comm)?))
-            }
-            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
-        }
-    }
-}
-
-impl Decodable for PedersenCommitment {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        let bytes = <[u8; 33]>::consensus_decode(d)?;
-        Ok(PedersenCommitment::from_slice(&bytes)?)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for Value {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::SerializeSeq;
-
-        let seq_len = match *self {
-            Value::Null => 1,
-            Value::Explicit(_) | Value::Confidential(_) => 2
-        };
-        let mut seq = s.serialize_seq(Some(seq_len))?;
-
-        match *self {
-            Value::Null => seq.serialize_element(&0u8)?,
-            Value::Explicit(n) => {
-                seq.serialize_element(&1u8)?;
-                seq.serialize_element(&u64::swap_bytes(n))?;
-            }
-            Value::Confidential(commitment) => {
-                seq.serialize_element(&2u8)?;
-                seq.serialize_element(&commitment)?;
-            }
-        }
-        seq.end()
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for Value {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        use serde::de::{Error, SeqAccess, Visitor};
-        struct CommitVisitor;
-
-        impl<'de> Visitor<'de> for CommitVisitor {
-            type Value = Value;
-
-            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.write_str("a committed value")
-            }
-
-            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Self::Value, A::Error> {
-                let prefix = access.next_element::<u8>()?;
-                match prefix {
-                    Some(0) => Ok(Value::Null),
-                    Some(1) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Value::Explicit(u64::swap_bytes(x))),
-                            None => Err(A::Error::custom("missing explicit value")),
-                        }
-                    }
-                    Some(2) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Value::Confidential(x)),
-                            None => Err(A::Error::custom("missing pedersen commitment")),
-                        }
-                    }
-                    _ => Err(A::Error::custom("wrong or missing prefix")),
-                }
-            }
-        }
-
-        d.deserialize_seq(CommitVisitor)
-    }
-}
-
-/// A CT commitment to an asset
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-pub enum Asset {
-    /// No value
-    Null,
-    /// Asset entropy is explicitly encoded
-    Explicit(AssetId),
-    /// Asset is committed
-    Confidential(Generator),
-}
-
-impl Asset {
-    /// Create asset commitment.
-    pub fn new_confidential<C: Signing>(
-        secp: &Secp256k1<C>,
-        asset: AssetId,
-        bf: AssetBlindingFactor,
-    ) -> Self {
-        Asset::Confidential(Generator::new_blinded(
-            secp,
-            asset.into_tag(),
-            bf.into_inner(),
-        ))
-    }
-
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Asset::Null => 1,
-            Asset::Explicit(..) => 33,
-            Asset::Confidential(..) => 33,
-        }
-    }
-
-    /// Create from commitment.
-    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
-        Ok(Asset::Confidential(Generator::from_slice(bytes)?))
-    }
-
-    /// Check if the object is null.
-    pub fn is_null(&self) -> bool {
-        match *self {
-            Asset::Null => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is explicit.
-    pub fn is_explicit(&self) -> bool {
-        match *self {
-            Asset::Explicit(_) => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is confidential.
-    pub fn is_confidential(&self) -> bool {
-        match *self {
-            Asset::Confidential(_) => true,
-            _ => false
-        }
-    }
-
-    /// Returns the explicit inner value.
-    /// Returns [None] if [is_explicit] returns false.
-    pub fn explicit(&self) -> Option<AssetId> {
-        match *self {
-            Asset::Explicit(i) => Some(i),
-            _ => None,
-        }
-    }
-
-    /// Returns the confidential commitment in case of a confidential value.
-    /// Returns [None] if [is_confidential] returns false.
-    pub fn commitment(&self) -> Option<Generator> {
-        match *self {
-            Asset::Confidential(i) => Some(i),
-            _ => None,
-        }
-    }
-
-    /// Internally used function for getting the generator from asset
-    /// Used in the amount verification check
-    /// Returns [`None`] is the asset is [`Asset::Null`]
-    /// Converts a explicit asset into a generator and returns the confidential
-    /// generator as is.
-    pub fn into_asset_gen<C: secp256k1_zkp::Signing> (
-        self,
-        secp: &Secp256k1<C>,
-    ) -> Option<Generator> {
-        match self {
-            // Only error is Null error which is dealt with later
-            // when we have more context information about it.
-            Asset::Null => return None,
-            Asset::Explicit(x) => {
-                Some(Generator::new_unblinded(secp, x.into_tag()))
-            }
-            Asset::Confidential(gen) => Some(gen),
-        }
-    }
-}
-
-impl From<Generator> for Asset {
-    fn from(from: Generator) -> Self {
-        Asset::Confidential(from)
-    }
-}
-
-impl fmt::Display for Asset {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Asset::Null => f.write_str("null"),
-            Asset::Explicit(n) => write!(f, "{}", n),
-            Asset::Confidential(generator) => write!(f, "{:02x}", generator),
-        }
-    }
-}
-
-impl Default for Asset {
-    fn default() -> Self {
-        Asset::Null
-    }
-}
-
-impl Encodable for Asset {
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
-        match *self {
-            Asset::Null => 0u8.consensus_encode(s),
-            Asset::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + n.consensus_encode(&mut s)?)
-            }
-            Asset::Confidential(generator) => generator.consensus_encode(&mut s)
-        }
-    }
-}
-
-impl Encodable for Generator {
-    fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
-        e.write_all(&self.serialize())?;
-        Ok(33)
-    }
-}
-
-impl Decodable for Asset {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
-
-        match prefix {
-            0 => Ok(Asset::Null),
-            1 => {
-                let explicit = Decodable::consensus_decode(&mut d)?;
-                Ok(Asset::Explicit(explicit))
-            }
-            p if p == 0x0a || p == 0x0b => {
-                let mut comm = [0u8; 33];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Asset::Confidential(Generator::from_slice(&comm[..])?))
-            }
-            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
-        }
-    }
-}
-
-impl Decodable for Generator {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        let bytes = <[u8; 33]>::consensus_decode(d)?;
-        Ok(Generator::from_slice(&bytes)?)
-    }
-}
-
-
-#[cfg(feature = "serde")]
-impl Serialize for Asset {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::SerializeSeq;
-
-        let seq_len = match *self {
-            Asset::Null => 1,
-            Asset::Explicit(_) | Asset::Confidential(_) => 2
-        };
-        let mut seq = s.serialize_seq(Some(seq_len))?;
-
-        match *self {
-            Asset::Null => seq.serialize_element(&0u8)?,
-            Asset::Explicit(n) => {
-                seq.serialize_element(&1u8)?;
-                seq.serialize_element(&n)?;
-            }
-            Asset::Confidential(commitment) => {
-                seq.serialize_element(&2u8)?;
-                seq.serialize_element(&commitment)?;
-            }
-        }
-        seq.end()
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for Asset {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        use serde::de::{Error, SeqAccess, Visitor};
-        struct CommitVisitor;
-
-        impl<'de> Visitor<'de> for CommitVisitor {
-            type Value = Asset;
-
-            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.write_str("a committed value")
-            }
-
-            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Asset, A::Error> {
-                let prefix = access.next_element::<u8>()?;
-                match prefix {
-                    Some(0) => Ok(Asset::Null),
-                    Some(1) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Asset::Explicit(x)),
-                            None => Err(A::Error::custom("missing explicit asset")),
-                        }
-                    }
-                    Some(2) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Asset::Confidential(x)),
-                            None => Err(A::Error::custom("missing generator")),
-                        }
-                    }
-                    _ => Err(A::Error::custom("wrong or missing prefix")),
-                }
-            }
-        }
-
-        d.deserialize_seq(CommitVisitor)
-    }
-}
-
-/// A CT commitment to an output nonce (i.e. a public key)
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
-pub enum Nonce {
-    /// No value
-    Null,
-    /// There should be no such thing as an "explicit nonce", but Elements will deserialize
-    /// such a thing (and insists that its size be 32 bytes). So we stick a 32-byte type here
-    /// that implements all the traits we need.
-    Explicit([u8; 32]),
-    /// Nonce is committed
-    Confidential(PublicKey),
-}
-
-impl Nonce {
-    /// Create nonce commitment.
-    pub fn new_confidential<R: RngCore + CryptoRng, C: Signing>(
-        rng: &mut R,
-        secp: &Secp256k1<C>,
-        receiver_blinding_pk: &PublicKey,
-    ) -> (Self, SecretKey) {
-        let ephemeral_sk = SecretKey::new(rng);
-        Self::with_ephemeral_sk(secp, ephemeral_sk, receiver_blinding_pk)
-    }
-
-    /// Similar to [Nonce::new_confidential], but with a given `ephemeral_sk`
-    /// instead of sampling it from rng.
-    pub fn with_ephemeral_sk<C: Signing>(
-        secp: &Secp256k1<C>,
-        ephemeral_sk: SecretKey,
-        receiver_blinding_pk: &PublicKey
-    ) -> (Self, SecretKey) {
-        let sender_pk = PublicKey::from_secret_key(&secp, &ephemeral_sk);
-        let shared_secret = Self::make_shared_secret(receiver_blinding_pk, &ephemeral_sk);
-        (Nonce::Confidential(sender_pk), shared_secret)
-    }
-
-    /// Calculate the shared secret.
-    pub fn shared_secret(&self, receiver_blinding_sk: &SecretKey) -> Option<SecretKey> {
-        match self {
-            Nonce::Confidential(sender_pk) => {
-                Some(Self::make_shared_secret(&sender_pk, receiver_blinding_sk))
-            }
-            _ => None,
-        }
-    }
-
-    /// Create the shared secret.
-    fn make_shared_secret(pk: &PublicKey, sk: &SecretKey) -> SecretKey {
-        let xy = secp256k1_zkp::ecdh::shared_secret_point(pk, sk);
-        let shared_secret = {
-            // Yes, what follows is the compressed representation of a Bitcoin public key.
-            // However, this is more by accident then by design, see here: https://github.com/rust-bitcoin/rust-secp256k1/pull/255#issuecomment-744146282
-
-            let mut dh_secret = [0u8; 33];
-            dh_secret[0] = if xy.last().unwrap() % 2 == 0 {
-                0x02
-            } else {
-                0x03
-            };
-            dh_secret[1..].copy_from_slice(&xy[0..32]);
-
-            sha256d::Hash::hash(&dh_secret).into_inner()
-        };
-
-        SecretKey::from_slice(&shared_secret.as_ref()[..32]).expect("always has exactly 32 bytes")
-    }
-
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Nonce::Null => 1,
-            Nonce::Explicit(..) => 33,
-            Nonce::Confidential(..) => 33,
-        }
-    }
-
-    /// Create from commitment.
-    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
-        Ok(Nonce::Confidential(
-            PublicKey::from_slice(bytes).map_err(secp256k1_zkp::Error::Upstream)?,
-        ))
-    }
-
-    /// Check if the object is null.
-    pub fn is_null(&self) -> bool {
-        match *self {
-            Nonce::Null => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is explicit.
-    pub fn is_explicit(&self) -> bool {
-        match *self {
-            Nonce::Explicit(_) => true,
-            _ => false
-        }
-    }
-
-    /// Check if the object is confidential.
-    pub fn is_confidential(&self) -> bool {
-        match *self {
-            Nonce::Confidential(_) => true,
-            _ => false
-        }
-    }
-
-    /// Returns the explicit inner value.
-    /// Returns [None] if [is_explicit] returns false.
-    pub fn explicit(&self) -> Option<[u8; 32]> {
-        match *self {
-            Nonce::Explicit(i) => Some(i),
-            _ => None,
-        }
-    }
-
-    /// Returns the confidential commitment in case of a confidential value.
-    /// Returns [None] if [is_confidential] returns false.
-    pub fn commitment(&self) -> Option<PublicKey> {
-        match *self {
-            Nonce::Confidential(i) => Some(i),
-            _ => None,
-        }
-    }
-}
-
-impl From<PublicKey> for Nonce {
-    fn from(from: PublicKey) -> Self {
-        Nonce::Confidential(from)
-    }
-}
-
-impl fmt::Display for Nonce {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Nonce::Null => f.write_str("null"),
-            Nonce::Explicit(n) => {
-                for b in n.iter() {
-                    write!(f, "{:02x}", b)?;
-                }
-                Ok(())
-            }
-            Nonce::Confidential(pk) => write!(f, "{:02x}", pk),
-        }
-    }
-}
-
-impl Default for Nonce {
-    fn default() -> Self {
-        Nonce::Null
-    }
-}
-
-impl Encodable for Nonce {
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
-        match *self {
-            Nonce::Null => 0u8.consensus_encode(s),
-            Nonce::Explicit(n) => {
-                1u8.consensus_encode(&mut s)?;
-                Ok(1 + n.consensus_encode(&mut s)?)
-            }
-            Nonce::Confidential(commitment) => commitment.consensus_encode(&mut s),
-        }
-    }
-}
-
-impl Encodable for PublicKey {
-    fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
-        e.write_all(&self.serialize())?;
-        Ok(33)
-    }
-}
-
-impl Decodable for Nonce {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let prefix = u8::consensus_decode(&mut d)?;
-
-        match prefix {
-            0 => Ok(Nonce::Null),
-            1 => {
-                let explicit = Decodable::consensus_decode(&mut d)?;
-                Ok(Nonce::Explicit(explicit))
-            }
-            p if p == 0x02 || p == 0x03 => {
-                let mut comm = [0u8; 33];
-                comm[0] = p;
-                d.read_exact(&mut comm[1..])?;
-                Ok(Nonce::Confidential(PublicKey::from_slice(&comm)?))
-            }
-            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
-        }
-    }
-}
-
-impl Decodable for PublicKey {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        let bytes = <[u8; 33]>::consensus_decode(d)?;
-        Ok(PublicKey::from_slice(&bytes)?)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for Nonce {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::SerializeSeq;
-
-        let seq_len = match *self {
-            Nonce::Null => 1,
-            Nonce::Explicit(_) | Nonce::Confidential(_) => 2
-        };
-        let mut seq = s.serialize_seq(Some(seq_len))?;
-
-        match *self {
-            Nonce::Null => seq.serialize_element(&0u8)?,
-            Nonce::Explicit(n) => {
-                seq.serialize_element(&1u8)?;
-                seq.serialize_element(&n)?;
-            }
-            Nonce::Confidential(commitment) => {
-                seq.serialize_element(&2u8)?;
-                seq.serialize_element(&commitment)?;
-            }
-        }
-        seq.end()
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for Nonce {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        use serde::de::{Error, SeqAccess, Visitor};
-        struct CommitVisitor;
-
-        impl<'de> Visitor<'de> for CommitVisitor {
-            type Value = Nonce;
-
-            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.write_str("a committed value")
-            }
-
-            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Nonce, A::Error> {
-                let prefix = access.next_element::<u8>()?;
-                match prefix {
-                    Some(0) => Ok(Nonce::Null),
-                    Some(1) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Nonce::Explicit(x)),
-                            None => Err(A::Error::custom("missing explicit nonce")),
-                        }
-                    }
-                    Some(2) => {
-                        match access.next_element()? {
-                            Some(x) => Ok(Nonce::Confidential(x)),
-                            None => Err(A::Error::custom("missing nonce")),
-                        }
-                    }
-                    _ => Err(A::Error::custom("wrong or missing prefix"))
-                }
-            }
-        }
-
-        d.deserialize_seq(CommitVisitor)
-    }
-}
-
-/// Blinding factor used for asset commitments.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
-pub struct AssetBlindingFactor(pub(crate) Tweak);
-
-impl AssetBlindingFactor {
-    /// Generate random asset blinding factor.
-    pub fn new<R: Rng>(rng: &mut R) -> Self {
-        AssetBlindingFactor(Tweak::new(rng))
-    }
-
-    /// Create from bytes.
-    pub fn from_slice(bytes: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
-        Ok(AssetBlindingFactor(Tweak::from_slice(bytes)?))
-    }
-
-    /// Returns the inner value.
-    pub fn into_inner(self) -> Tweak {
-        self.0
-    }
-
-    /// Get a unblinded/zero AssetBlinding factor
-    pub fn zero() -> Self {
-        AssetBlindingFactor(ZERO_TWEAK)
-    }
-}
-
-impl hex::FromHex for AssetBlindingFactor {
-    fn from_byte_iter<I>(iter: I) -> Result<Self, hex::Error>
-        where I: Iterator<Item=Result<u8, hex::Error>> +
-            ExactSizeIterator +
-            DoubleEndedIterator
-    {
-        let slice = <[u8; 32]>::from_byte_iter(iter.rev())?;
-        // Incorrect Return Error
-        // See: https://github.com/rust-bitcoin/bitcoin_hashes/issues/124
-        let inner = Tweak::from_inner(slice)
-            .map_err(|_e| hex::Error::InvalidChar(0))?;
-        Ok(AssetBlindingFactor(inner))
-    }
-}
-
-impl fmt::Display for AssetBlindingFactor {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        hex::format_hex_reverse(self.0.as_ref(), f)
-    }
-}
-
-impl fmt::LowerHex for AssetBlindingFactor {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        hex::format_hex_reverse(self.0.as_ref(), f)
-    }
-}
-
-impl str::FromStr for AssetBlindingFactor {
-    type Err = encode::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(hex::FromHex::from_hex(s)?)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for AssetBlindingFactor {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        if s.is_human_readable() {
-            s.collect_str(&self)
-        } else {
-            s.serialize_bytes(&self.0[..])
-        }
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for AssetBlindingFactor {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<AssetBlindingFactor, D::Error> {
-        use bitcoin::hashes::hex::FromHex;
-
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = AssetBlindingFactor;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
-                        AssetBlindingFactor::from_hex(hex).map_err(E::custom)
-                    } else {
-                        return 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,
-                {
-                    AssetBlindingFactor::from_hex(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_str(HexVisitor)
-        } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = AssetBlindingFactor;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if v.len() != 32 {
-                        Err(E::invalid_length(v.len(), &stringify!($len)))
-                    } else {
-                        let mut ret = [0; 32];
-                        ret.copy_from_slice(v);
-                        let inner = Tweak::from_inner(ret).map_err(E::custom)?;
-                        Ok(AssetBlindingFactor(inner))
-                    }
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
-        }
-    }
-}
-
-/// Blinding factor used for value commitments.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
-pub struct ValueBlindingFactor(pub(crate) Tweak);
-
-impl ValueBlindingFactor {
-    /// Generate random value blinding factor.
-    pub fn new<R: Rng>(rng: &mut R) -> Self {
-        ValueBlindingFactor(Tweak::new(rng))
-    }
-
-    /// Create the value blinding factor of the last output of a transaction.
-    pub fn last<C: Signing>(
-        secp: &Secp256k1<C>,
-        value: u64,
-        abf: AssetBlindingFactor,
-        inputs: &[(u64, AssetBlindingFactor, ValueBlindingFactor)],
-        outputs: &[(u64, AssetBlindingFactor, ValueBlindingFactor)],
-    ) -> Self {
-        let set_a = inputs
-            .iter()
-            .map(|(value, abf, vbf)| CommitmentSecrets {
-                value: *value,
-                value_blinding_factor: vbf.0,
-                generator_blinding_factor: abf.into_inner(),
-            })
-            .collect::<Vec<_>>();
-        let set_b = outputs
-            .iter()
-            .map(|(value, abf, vbf)| CommitmentSecrets {
-                value: *value,
-                value_blinding_factor: vbf.0,
-                generator_blinding_factor: abf.into_inner(),
-            })
-            .collect::<Vec<_>>();
-
-        ValueBlindingFactor(compute_adaptive_blinding_factor(
-            secp, value, abf.0, &set_a, &set_b,
-        ))
-    }
-
-    /// Create from bytes.
-    pub fn from_slice(bytes: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
-        Ok(ValueBlindingFactor(Tweak::from_slice(bytes)?))
-    }
-
-    /// Returns the inner value.
-    pub fn into_inner(self) -> Tweak {
-        self.0
-    }
-
-    /// Get a unblinded/zero AssetBlinding factor
-    pub fn zero() -> Self {
-        ValueBlindingFactor(ZERO_TWEAK)
-    }
-}
-
-impl AddAssign for ValueBlindingFactor {
-    fn add_assign(&mut self, other: Self) {
-        if self.0.as_ref() == &[0u8; 32] {
-            *self = other;
-        } else if other.0.as_ref() == &[0u8; 32] {
-            // nothing to do
-        } else {
-            // Since libsecp does not expose low level APIs
-            // for scalar arethematic, we need to abuse secret key
-            // operations for this
-            let sk2 = SecretKey::from_slice(self.into_inner().as_ref()).expect("Valid key");
-            let sk = SecretKey::from_slice(other.into_inner().as_ref()).expect("Valid key");
-            // The only reason that secret key addition can fail
-            // is when the keys add up to zero since we have already checked
-            // keys are in valid secret keys
-            match sk.add_tweak(&sk2.into()) {
-                Ok(sk_tweaked) => *self = ValueBlindingFactor::from_slice(sk_tweaked.as_ref()).expect("Valid Tweak"),
-                Err(_) =>  *self = Self::zero(),
-            }
-        }
-    }
-}
-
-impl Neg for ValueBlindingFactor {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output {
-        if self.0.as_ref() == &[0u8; 32] {
-            self
-        } else {
-            let sk = SecretKey::from_slice(self.into_inner().as_ref()).expect("Valid key").negate();
-            ValueBlindingFactor::from_slice(sk.as_ref()).expect("Valid Tweak")
-        }
-    }
-}
-
-impl hex::FromHex for ValueBlindingFactor {
-    fn from_byte_iter<I>(iter: I) -> Result<Self, hex::Error>
-        where I: Iterator<Item=Result<u8, hex::Error>> +
-            ExactSizeIterator +
-            DoubleEndedIterator
-    {
-        let slice = <[u8; 32]>::from_byte_iter(iter.rev())?;
-        // Incorrect Return Error
-        // See: https://github.com/rust-bitcoin/bitcoin_hashes/issues/124
-        let inner = Tweak::from_inner(slice)
-            .map_err(|_e| hex::Error::InvalidChar(0))?;
-        Ok(ValueBlindingFactor(inner))
-    }
-}
-
-impl fmt::Display for ValueBlindingFactor {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        hex::format_hex_reverse(self.0.as_ref(), f)
-    }
-}
-
-impl fmt::LowerHex for ValueBlindingFactor {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        hex::format_hex_reverse(self.0.as_ref(), f)
-    }
-}
-
-impl str::FromStr for ValueBlindingFactor {
-    type Err = encode::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(hex::FromHex::from_hex(s)?)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl Serialize for ValueBlindingFactor {
-    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        if s.is_human_readable() {
-            s.collect_str(&self)
-        } else {
-            s.serialize_bytes(&self.0[..])
-        }
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for ValueBlindingFactor {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<ValueBlindingFactor, D::Error> {
-        use bitcoin::hashes::hex::FromHex;
-
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = ValueBlindingFactor;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
-                        ValueBlindingFactor::from_hex(hex).map_err(E::custom)
-                    } else {
-                        return 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,
-                {
-                    ValueBlindingFactor::from_hex(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_str(HexVisitor)
-        } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = ValueBlindingFactor;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if v.len() != 32 {
-                        Err(E::invalid_length(v.len(), &stringify!($len)))
-                    } else {
-                        let mut ret = [0; 32];
-                        ret.copy_from_slice(v);
-                        let inner = Tweak::from_inner(ret).map_err(E::custom)?;
-                        Ok(ValueBlindingFactor(inner))
-                    }
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bitcoin::hashes::sha256;
-
-    #[cfg(feature = "serde")]
-    use bincode;
-
-    #[test]
-    fn encode_length() {
-        let vals = [
-            Value::Null,
-            Value::Explicit(1000),
-            Value::from_commitment(&[
-                0x08, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                1, 1, 1, 1, 1, 1,
-            ])
-            .unwrap(),
-        ];
-        for v in &vals[..] {
-            let mut x = vec![];
-            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
-            assert_eq!(x.len(), v.encoded_length());
-        }
-
-        let nonces = [
-            Nonce::Null,
-            Nonce::Explicit([0; 32]),
-            Nonce::from_commitment(&[
-                0x02, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                1, 1, 1, 1, 1, 1,
-            ])
-            .unwrap(),
-        ];
-        for v in &nonces[..] {
-            let mut x = vec![];
-            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
-            assert_eq!(x.len(), v.encoded_length());
-        }
-
-        let assets = [
-            Asset::Null,
-            Asset::Explicit(AssetId::from_inner(sha256::Midstate::from_inner([0; 32]))),
-            Asset::from_commitment(&[
-                0x0a, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                1, 1, 1, 1, 1, 1,
-            ])
-            .unwrap(),
-        ];
-        for v in &assets[..] {
-            let mut x = vec![];
-            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
-            assert_eq!(x.len(), v.encoded_length());
-        }
-    }
-
-    #[test]
-    fn commitments() {
-        let x = Value::from_commitment(&[
-            0x08, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1,
-        ])
-        .unwrap();
-        let commitment = x.commitment().unwrap();
-        let mut commitment = commitment.serialize();
-        assert_eq!(x, Value::from_commitment(&commitment[..]).unwrap());
-        commitment[0] = 42;
-        assert!(Value::from_commitment(&commitment[..]).is_err());
-
-        let x = Asset::from_commitment(&[
-            0x0a, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1,
-        ])
-        .unwrap();
-        let commitment = x.commitment().unwrap();
-        let mut commitment = commitment.serialize();
-        assert_eq!(x, Asset::from_commitment(&commitment[..]).unwrap());
-        commitment[0] = 42;
-        assert!(Asset::from_commitment(&commitment[..]).is_err());
-
-        let x = Nonce::from_commitment(&[
-            0x02, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1,
-        ])
-        .unwrap();
-        let commitment = x.commitment().unwrap();
-        let mut commitment = commitment.serialize();
-        assert_eq!(x, Nonce::from_commitment(&commitment[..]).unwrap());
-        commitment[0] = 42;
-        assert!(Nonce::from_commitment(&commitment[..]).is_err());
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn value_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
-        let value = Value::Explicit(100_000_000);
-        assert_tokens(
-            &value,
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(1),
-                Token::U64(63601271583539200),
-                Token::SeqEnd
-            ]
-        );
-
-        let value = Value::from_commitment(&[
-            0x08,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        ]).unwrap();
-        assert_tokens(
-            &value.readable(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Str(
-                    "080101010101010101010101010101010101010101010101010101010101010101"
-                ),
-                Token::SeqEnd
-            ]
-        );
-        assert_tokens(
-            &value.compact(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Bytes(
-                    &[
-                        8,
-                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
-                    ]
-                ),
-                Token::SeqEnd
-            ]
-        );
-
-        let value = Value::Null;
-        assert_tokens(
-            &value,
-            &[
-                Token::Seq { len: Some(1) },
-                Token::U8(0),
-                Token::SeqEnd
-            ]
-        );
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn asset_serde() {
-        use bitcoin::hashes::hex::FromHex;
-        use serde_test::{assert_tokens, Configure, Token};
-
-        let asset_id = AssetId::from_hex(
-            "630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8"
-        ).unwrap();
-        let asset = Asset::Explicit(asset_id);
-        assert_tokens(
-            &asset.readable(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(1),
-                Token::Str(
-                    "630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8"
-                ),
-                Token::SeqEnd
-            ]
-        );
-        assert_tokens(
-            &asset.compact(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(1),
-                Token::Bytes(
-                    &[
-                        248, 11, 176, 3, 143, 72, 34, 67, 32, 47, 11, 45, 207, 136, 217, 180,
-                        231, 249, 48, 164, 138, 63, 205, 192, 3, 175, 118, 177, 249, 214, 14, 99
-                    ]
-                ),
-                Token::SeqEnd
-            ]
-        );
-
-        let asset = Asset::from_commitment(&[
-            0x0a,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        ]).unwrap();
-        assert_tokens(
-            &asset.readable(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Str(
-                    "0a0101010101010101010101010101010101010101010101010101010101010101"
-                ),
-                Token::SeqEnd
-            ]
-        );
-        assert_tokens(
-            &asset.compact(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Bytes(
-                    &[
-                        10,
-                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
-                    ]
-                ),
-                Token::SeqEnd
-            ]
-        );
-
-        let asset = Asset::Null;
-        assert_tokens(
-            &asset,
-            &[
-                Token::Seq { len: Some(1) },
-                Token::U8(0),
-                Token::SeqEnd
-            ]
-        );
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn nonce_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
-        let nonce = Nonce::Explicit([
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        ]);
-        assert_tokens(
-            &nonce,
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(1),
-                Token::Tuple { len: 32 },
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::TupleEnd,
-                Token::SeqEnd
-            ]
-        );
-
-        let nonce = Nonce::from_commitment(&[
-            0x02,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        ]).unwrap();
-        assert_tokens(
-            &nonce.readable(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Str(
-                    "020101010101010101010101010101010101010101010101010101010101010101"
-                ),
-                Token::SeqEnd
-            ]
-        );
-        assert_tokens(
-            &nonce.compact(),
-            &[
-                Token::Seq { len: Some(2) },
-                Token::U8(2),
-                Token::Tuple { len: 33 },
-                Token::U8(2), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
-                Token::U8(1),
-                Token::TupleEnd,
-                Token::SeqEnd
-            ]
-        );
-
-        let nonce = Nonce::Null;
-        assert_tokens(
-            &nonce,
-            &[
-                Token::Seq { len: Some(1) },
-                Token::U8(0),
-                Token::SeqEnd
-            ]
-        );
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn bf_serde() {
-        use serde_json;
-        use std::str::FromStr;
-
-        let abf_str = "a5b3d111cdaa5fc111e2723df4caf315864f25fb4610cc737f10d5a55cd4096f";
-        let abf_str_quoted = format!("\"{}\"", abf_str);
-        let abf_from_serde: AssetBlindingFactor = serde_json::from_str(&abf_str_quoted).unwrap();
-        let abf_from_str = AssetBlindingFactor::from_str(abf_str).unwrap();
-        assert_eq!(abf_from_serde, abf_from_str);
-        assert_eq!(abf_str_quoted, serde_json::to_string(&abf_from_serde).unwrap());
-
-        let vbf_str = "e36a4de359469f547571d117bc5509fb74fba73c84b0cdd6f4edfa7ff7fa457d";
-        let vbf_str_quoted = format!("\"{}\"", vbf_str);
-        let vbf_from_serde: ValueBlindingFactor = serde_json::from_str(&vbf_str_quoted).unwrap();
-        let vbf_from_str = ValueBlindingFactor::from_str(vbf_str).unwrap();
-        assert_eq!(vbf_from_serde, vbf_from_str);
-        assert_eq!(vbf_str_quoted, serde_json::to_string(&vbf_from_serde).unwrap());
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn test_value_bincode_be() {
-        let value = Value::Explicit(500);
-        let bytes = bincode::serialize(&value).unwrap();
-        let decoded: Value = bincode::deserialize(&bytes).unwrap();
-        assert_eq!(value, decoded);
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn test_value_bincode_le() {
-        use bincode::Options;
-        let value = Value::Explicit(500);
-        let bytes = bincode::DefaultOptions::default()
-            .with_little_endian()
-            .serialize(&value)
-            .unwrap();
-        let decoded: Value = bincode::DefaultOptions::default()
-            .with_little_endian()
-            .deserialize(&bytes)
-            .unwrap();
-        assert_eq!(value, decoded);
-    }
-}
diff --git a/src/confidential/asset.rs b/src/confidential/asset.rs
new file mode 100644
index 00000000..5636b4bf
--- /dev/null
+++ b/src/confidential/asset.rs
@@ -0,0 +1,458 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Confiential Assets
+
+use core::{fmt, str};
+use std::io;
+
+use secp256k1_zkp::rand::Rng;
+use secp256k1_zkp::{self, Generator, Secp256k1, Signing, Tweak, ZERO_TWEAK};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::CommitmentEncoder;
+use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
+use crate::issuance::AssetId;
+
+type ExplicitInner = AssetId;
+type ConfInner = Generator;
+
+const EXPLICIT_LEN: usize = 32;
+const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
+const CONF_PREFIX_1: u8 = 0x0a;
+const CONF_PREFIX_2: u8 = 0x0b;
+
+/// A CT commitment to an asset
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub enum Asset {
+    /// No value
+    #[default]
+    Null,
+    /// Asset entropy is explicitly encoded
+    Explicit(ExplicitInner),
+    /// Asset is committed
+    Confidential(ConfInner),
+}
+
+impl Asset {
+    /// Create asset commitment.
+    pub fn new_confidential<C: Signing>(
+        secp: &Secp256k1<C>,
+        asset: AssetId,
+        bf: BlindingFactor,
+    ) -> Self {
+        Self::Confidential(ConfInner::new_blinded(secp, asset.into_tag(), bf.into_inner()))
+    }
+
+    /// Serialized length, in bytes
+    pub fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 1 + EXPLICIT_LEN,
+            Self::Confidential(..) => CONFIDENTIAL_LEN,
+        }
+    }
+
+    /// Create from commitment.
+    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
+        Ok(Self::Confidential(ConfInner::from_slice(bytes)?))
+    }
+
+    /// Check if the object is null.
+    pub fn is_null(&self) -> bool { matches!(*self, Self::Null) }
+
+    /// Check if the object is explicit.
+    pub fn is_explicit(&self) -> bool { matches!(*self, Self::Explicit(_)) }
+
+    /// Check if the object is confidential.
+    pub fn is_confidential(&self) -> bool { matches!(*self, Self::Confidential(_)) }
+
+    /// Returns the explicit inner value.
+    /// Returns [None] if [`Self::is_explicit`] returns false.
+    pub fn explicit(&self) -> Option<ExplicitInner> {
+        match *self {
+            Self::Explicit(i) => Some(i),
+            _ => None,
+        }
+    }
+
+    /// Returns the confidential commitment in case of a confidential value.
+    /// Returns [None] if [`Self::is_confidential`] returns false.
+    pub fn commitment(&self) -> Option<ConfInner> {
+        match *self {
+            Self::Confidential(i) => Some(i),
+            _ => None,
+        }
+    }
+
+    /// Internally used function for getting the generator from asset
+    /// Used in the amount verification check
+    /// Returns [`None`] is the asset is [`Self::Null`]
+    /// Converts a explicit asset into a generator and returns the confidential
+    /// generator as is.
+    pub fn into_asset_gen<C: secp256k1_zkp::Signing>(
+        self,
+        secp: &Secp256k1<C>,
+    ) -> Option<ConfInner> {
+        match self {
+            // Only error is Null error which is dealt with later
+            // when we have more context information about it.
+            Self::Null => None,
+            Self::Explicit(x) => Some(ConfInner::new_unblinded(secp, x.into_tag())),
+            Self::Confidential(gen) => Some(gen),
+        }
+    }
+}
+
+impl From<ConfInner> for Asset {
+    fn from(from: ConfInner) -> Self { Self::Confidential(from) }
+}
+
+impl fmt::Display for Asset {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Null => f.write_str("null"),
+            Self::Explicit(n) => write!(f, "{}", n),
+            Self::Confidential(generator) => write!(f, "{:02x}", generator),
+        }
+    }
+}
+
+impl Encodable for Asset {
+    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
+        match *self {
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
+            Self::Explicit(n) => {
+                s.write_all(&[1u8])?;
+                s.write_all(n.as_byte_array())?;
+                Ok(1 + EXPLICIT_LEN)
+            }
+            Self::Confidential(generator) => {
+                s.write_all(&generator.serialize())?;
+                Ok(CONFIDENTIAL_LEN)
+            }
+        }
+    }
+}
+
+impl Decodable for Asset {
+    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
+
+        match buf[0] {
+            0 => Ok(Self::Null),
+            1 => {
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(AssetId::from_byte_array(buf)))
+            }
+            p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf[..])?))
+            }
+            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Asset {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeSeq;
+
+        let seq_len = match *self {
+            Self::Null => 1,
+            Self::Explicit(_) | Self::Confidential(_) => 2,
+        };
+        let mut seq = s.serialize_seq(Some(seq_len))?;
+
+        match *self {
+            Self::Null => seq.serialize_element(&0u8)?,
+            Self::Explicit(n) => {
+                seq.serialize_element(&1u8)?;
+                seq.serialize_element(&n)?;
+            }
+            Self::Confidential(commitment) => {
+                seq.serialize_element(&2u8)?;
+                seq.serialize_element(&commitment)?;
+            }
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Asset {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde::de::{Error, SeqAccess, Visitor};
+        struct CommitVisitor;
+
+        impl<'de> Visitor<'de> for CommitVisitor {
+            type Value = Asset;
+
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("a committed value")
+            }
+
+            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Self::Value, A::Error> {
+                let prefix = access.next_element::<u8>()?;
+                match prefix {
+                    Some(0) => Ok(Self::Value::Null),
+                    Some(1) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Explicit(x)),
+                        None => Err(A::Error::custom("missing explicit asset")),
+                    },
+                    Some(2) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Confidential(x)),
+                        None => Err(A::Error::custom("missing generator")),
+                    },
+                    _ => Err(A::Error::custom("wrong or missing prefix")),
+                }
+            }
+        }
+
+        d.deserialize_seq(CommitVisitor)
+    }
+}
+
+/// Blinding factor used for asset commitments.
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct BlindingFactor(pub(crate) Tweak);
+
+impl BlindingFactor {
+    /// Generate random asset blinding factor.
+    pub fn new<R: Rng>(rng: &mut R) -> Self { Self(Tweak::new(rng)) }
+
+    /// Parse a blinding factor from a 64-character hex string.
+    #[deprecated(since = "0.27.0", note = "use s.parse() instead")]
+    pub fn from_hex(s: &str) -> Result<Self, encode::Error> { s.parse() }
+
+    /// Create from bytes.
+    pub fn from_byte_array(bytes: [u8; 32]) -> Result<Self, secp256k1_zkp::Error> {
+        Ok(Self(Tweak::from_inner(bytes)?))
+    }
+
+    /// Create from bytes.
+    pub fn from_slice(bytes: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
+        Ok(Self(Tweak::from_slice(bytes)?))
+    }
+
+    /// Returns the inner value.
+    pub fn into_inner(self) -> Tweak { self.0 }
+
+    /// Get a unblinded/zero `AssetBlinding` factor
+    pub fn zero() -> Self { Self(ZERO_TWEAK) }
+}
+
+impl core::borrow::Borrow<[u8]> for BlindingFactor {
+    fn borrow(&self) -> &[u8] { &self.0[..] }
+}
+
+hex::impl_fmt_traits! {
+    #[display_backward(true)]
+    impl fmt_traits for BlindingFactor {
+        const LENGTH: usize = 32;
+    }
+}
+
+impl str::FromStr for BlindingFactor {
+    type Err = encode::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut slice: [u8; 32] = hex::decode_to_array(s)?;
+        slice.reverse();
+
+        let inner = Tweak::from_inner(slice)?;
+        Ok(Self(inner))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for BlindingFactor {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        if s.is_human_readable() {
+            s.collect_str(&self)
+        } else {
+            s.serialize_bytes(&self.0[..])
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for BlindingFactor {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        if d.is_human_readable() {
+            struct HexVisitor;
+
+            impl ::serde::de::Visitor<'_> for HexVisitor {
+                type Value = BlindingFactor;
+
+                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
+                        hex.parse().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,
+                {
+                    v.parse().map_err(E::custom)
+                }
+            }
+
+            d.deserialize_str(HexVisitor)
+        } else {
+            struct BytesVisitor;
+
+            impl ::serde::de::Visitor<'_> for BytesVisitor {
+                type Value = BlindingFactor;
+
+                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                    formatter.write_str("a bytestring")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: ::serde::de::Error,
+                {
+                    use core::convert::TryFrom;
+
+                    match <[u8; 32]>::try_from(v) {
+                        Ok(ret) => {
+                            let inner = Tweak::from_inner(ret).map_err(E::custom)?;
+                            Ok(BlindingFactor(inner))
+                        }
+                        Err(_) => Err(E::invalid_length(v.len(), &stringify!($len))),
+                    }
+                }
+            }
+
+            d.deserialize_bytes(BytesVisitor)
+        }
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Asset`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Asset {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit32(Some(1), id.as_byte_array()),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Asset`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Asset),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Asset::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Asset::Explicit(AssetId::from_byte_array(bytes))))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Asset::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Asset`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(secp256k1_zkp::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/confidential/mod.rs b/src/confidential/mod.rs
new file mode 100644
index 00000000..22fe9542
--- /dev/null
+++ b/src/confidential/mod.rs
@@ -0,0 +1,560 @@
+// Rust Elements Library
+// Written in 2018 by
+//   Andrew Poelstra <apoelstra@blockstream.com>
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//! # Confidential Commitments
+//!
+//! Structures representing Pedersen commitments of various types
+//!
+
+#![warn(clippy::use_self)]
+
+mod asset;
+mod nonce;
+mod range_proof;
+mod surjection_proof;
+mod value;
+
+use core::{fmt, slice};
+
+use secp256k1_zkp;
+
+pub use self::asset::{
+    Asset, BlindingFactor as AssetBlindingFactor, Decoder as AssetDecoder,
+    DecoderError as AssetDecoderError, Encoder as AssetEncoder,
+};
+pub use self::nonce::{
+    Decoder as NonceDecoder, DecoderError as NonceDecoderError, Encoder as NonceEncoder, Nonce,
+};
+pub use self::range_proof::{
+    Decoder as RangeProofDecoder, DecoderError as RangeProofDecoderError,
+    Encoder as RangeProofEncoder, RangeProof,
+};
+pub use self::surjection_proof::{
+    Decoder as SurjectionProofDecoder, DecoderError as SurjectionProofDecoderError,
+    Encoder as SurjectionProofEncoder, SurjectionProof,
+};
+pub use self::value::{
+    BlindingFactor as ValueBlindingFactor, Decoder as ValueDecoder,
+    DecoderError as ValueDecoderError, Encoder as ValueEncoder, Value,
+};
+use crate::issuance::AssetId;
+use crate::{encode, encoding};
+
+#[derive(Clone, Debug)]
+enum CommitmentEncoder<'e> {
+    Null(u8),
+    Explicit8(Option<u8>, [u8; 8]),
+    Explicit32(Option<u8>, &'e [u8; 32]),
+    Explicit33([u8; 33]),
+}
+
+impl encoding::Encoder for CommitmentEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        match *self {
+            Self::Null(ref prefix) => slice::from_ref(prefix),
+            Self::Explicit8(ref prefix, ref arr) => prefix.as_ref().map_or(arr, slice::from_ref),
+            Self::Explicit32(ref prefix, arr) => prefix.as_ref().map_or(arr, slice::from_ref),
+            Self::Explicit33(ref arr) => arr,
+        }
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        match *self {
+            Self::Explicit8(ref mut prefix @ Some(_), _)
+            | Self::Explicit32(ref mut prefix @ Some(_), _) => {
+                *prefix = None;
+                encoding::EncoderStatus::HasMore
+            }
+            _ => encoding::EncoderStatus::Finished,
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for CommitmentEncoder<'_> {
+    fn len(&self) -> usize {
+        match *self {
+            Self::Null(_) => 1,
+            Self::Explicit8(Some(_), _) => 9,
+            Self::Explicit8(None, _) => 8,
+            Self::Explicit32(Some(_), _) => 33,
+            Self::Explicit32(None, _) => 32,
+            Self::Explicit33(_) => 33,
+        }
+    }
+}
+
+/// Because the rust-secp256k1-zkp proof types have no `as_bytes()` method, we need
+/// to serialize them to a byte vector before encoding them.
+///
+/// This encoder accomplishes that -- this situation never happens in rust-bitcoin
+/// so there is no "owned bytes encoder" shipped with bitcoin-consensus-encoding.
+#[derive(Clone, Debug)]
+struct PrefixedByteVecEncoder {
+    prefix_encoder: Option<encoding::CompactSizeEncoder>,
+    data: Vec<u8>,
+}
+
+impl PrefixedByteVecEncoder {
+    pub fn new(data: Vec<u8>) -> Self {
+        Self { prefix_encoder: Some(encoding::CompactSizeEncoder::new(data.len())), data }
+    }
+}
+
+impl encoding::Encoder for PrefixedByteVecEncoder {
+    fn current_chunk(&self) -> &[u8] {
+        if let Some(ref enc) = self.prefix_encoder {
+            return enc.current_chunk();
+        }
+        &self.data
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        if let Some(ref mut enc) = self.prefix_encoder {
+            if enc.advance().has_finished() {
+                self.prefix_encoder = None;
+                if self.data.is_empty() {
+                    return encoding::EncoderStatus::Finished;
+                }
+            }
+            encoding::EncoderStatus::HasMore
+        } else {
+            encoding::EncoderStatus::Finished
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for PrefixedByteVecEncoder {
+    fn len(&self) -> usize {
+        self.prefix_encoder.as_ref().map_or(0, encoding::CompactSizeEncoder::len) + self.data.len()
+    }
+}
+
+/// Error decoding hexadecimal string into tweak-like value.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TweakHexDecodeError {
+    /// Invalid hexadecimal string.
+    InvalidHex(hex::DecodeFixedLengthBytesError),
+    /// Invalid tweak after decoding hexadecimal string.
+    InvalidTweak(secp256k1_zkp::Error),
+}
+
+impl fmt::Display for TweakHexDecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::InvalidHex(err) => {
+                write!(f, "Invalid hex: {}", err)
+            }
+            Self::InvalidTweak(err) => {
+                write!(f, "Invalid tweak: {}", err)
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+impl From<hex::DecodeFixedLengthBytesError> for TweakHexDecodeError {
+    fn from(err: hex::DecodeFixedLengthBytesError) -> Self { Self::InvalidHex(err) }
+}
+
+#[doc(hidden)]
+impl From<secp256k1_zkp::Error> for TweakHexDecodeError {
+    fn from(err: secp256k1_zkp::Error) -> Self { Self::InvalidTweak(err) }
+}
+
+impl From<TweakHexDecodeError> for encode::Error {
+    fn from(value: TweakHexDecodeError) -> Self {
+        match value {
+            TweakHexDecodeError::InvalidHex(err) => Self::HexFixedError(err),
+            TweakHexDecodeError::InvalidTweak(err) => Self::Secp256k1zkp(err),
+        }
+    }
+}
+
+impl std::error::Error for TweakHexDecodeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::InvalidHex(err) => Some(err),
+            Self::InvalidTweak(err) => Some(err),
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "serde")]
+    use std::str::FromStr;
+
+    #[cfg(feature = "serde")]
+    use bincode;
+
+    use super::*;
+    use crate::encode::Encodable as _;
+    use crate::encoding;
+
+    const VALUE_EXPLICIT: [u8; 9] = [1, 0, 0, 0, 0, 0, 0, 3, 232];
+
+    const VALUE_COMMITMENT1: [u8; 33] = [
+        0x08, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    const VALUE_COMMITMENT2: [u8; 33] = [
+        0x09, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    const NONCE_EXPLICIT: [u8; 33] = [
+        0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0,
+    ];
+
+    const NONCE_COMMITMENT1: [u8; 33] = [
+        0x02, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    const NONCE_COMMITMENT2: [u8; 33] = [
+        0x03, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    const ASSET_EXPLICIT: [u8; 33] = [
+        0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0,
+    ];
+
+    const ASSET_COMMITMENT1: [u8; 33] = [
+        0x0a, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    const ASSET_COMMITMENT2: [u8; 33] = [
+        0x0b, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1,
+    ];
+
+    #[test]
+    fn prefixed_byte_encoder() {
+        assert_eq!(encoding::drain_to_vec(&mut PrefixedByteVecEncoder::new(vec![])), [0]);
+        assert_eq!(
+            encoding::drain_to_vec(&mut PrefixedByteVecEncoder::new(vec![1, 2, 3])),
+            [3, 1, 2, 3]
+        );
+    }
+
+    #[test]
+    fn encode_length() {
+        let val_encodings = [
+            vec![0],
+            VALUE_EXPLICIT.to_vec(),
+            VALUE_COMMITMENT1.to_vec(),
+            VALUE_COMMITMENT2.to_vec(),
+        ];
+        let vals = [
+            Value::Null,
+            Value::Explicit(1000),
+            Value::from_commitment(&VALUE_COMMITMENT1).unwrap(),
+            Value::from_commitment(&VALUE_COMMITMENT2).unwrap(),
+        ];
+        for (v, enc) in vals.iter().zip(val_encodings.iter()) {
+            let mut x = vec![];
+            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
+            assert_eq!(x.len(), v.encoded_length());
+            assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
+        }
+
+        let nonce_encodings = [
+            vec![0],
+            NONCE_EXPLICIT.to_vec(),
+            NONCE_COMMITMENT1.to_vec(),
+            NONCE_COMMITMENT2.to_vec(),
+        ];
+        let nonces = [
+            Nonce::Null,
+            Nonce::Explicit([0; 32]),
+            Nonce::from_commitment(&NONCE_COMMITMENT1).unwrap(),
+            Nonce::from_commitment(&NONCE_COMMITMENT2).unwrap(),
+        ];
+        for (v, enc) in nonces.iter().zip(nonce_encodings.iter()) {
+            let mut x = vec![];
+            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
+            assert_eq!(x.len(), v.encoded_length());
+            assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
+        }
+
+        let asset_encodings = [
+            vec![0],
+            ASSET_EXPLICIT.to_vec(),
+            ASSET_COMMITMENT1.to_vec(),
+            ASSET_COMMITMENT2.to_vec(),
+        ];
+        let assets = [
+            Asset::Null,
+            Asset::Explicit(AssetId::from_byte_array([0; 32])),
+            Asset::from_commitment(&ASSET_COMMITMENT1).unwrap(),
+            Asset::from_commitment(&ASSET_COMMITMENT2).unwrap(),
+        ];
+        for (v, enc) in assets.iter().zip(asset_encodings.iter()) {
+            let mut x = vec![];
+            assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
+            assert_eq!(x.len(), v.encoded_length());
+            assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
+        }
+    }
+
+    #[test]
+    fn commitments() {
+        let x = Value::from_commitment(&VALUE_COMMITMENT1).unwrap();
+        let commitment = x.commitment().unwrap();
+        let mut commitment = commitment.serialize();
+        assert_eq!(x, Value::from_commitment(&commitment[..]).unwrap());
+        commitment[0] = 42;
+        assert!(Value::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), VALUE_COMMITMENT1);
+
+        let x = Asset::from_commitment(&ASSET_COMMITMENT1).unwrap();
+        let commitment = x.commitment().unwrap();
+        let mut commitment = commitment.serialize();
+        assert_eq!(x, Asset::from_commitment(&commitment[..]).unwrap());
+        commitment[0] = 42;
+        assert!(Asset::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), ASSET_COMMITMENT1);
+
+        let x = Nonce::from_commitment(&NONCE_COMMITMENT1).unwrap();
+        let commitment = x.commitment().unwrap();
+        let mut commitment = commitment.serialize();
+        assert_eq!(x, Nonce::from_commitment(&commitment[..]).unwrap());
+        commitment[0] = 42;
+        assert!(Nonce::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), NONCE_COMMITMENT1);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn value_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        let value = Value::Explicit(100_000_000);
+        assert_tokens(
+            &value,
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(1),
+                Token::U64(63_601_271_583_539_200),
+                Token::SeqEnd,
+            ],
+        );
+
+        let value = Value::from_commitment(&VALUE_COMMITMENT1).unwrap();
+        assert_tokens(
+            &value.readable(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Str("080101010101010101010101010101010101010101010101010101010101010101"),
+                Token::SeqEnd,
+            ],
+        );
+        assert_tokens(
+            &value.compact(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Bytes(&VALUE_COMMITMENT1),
+                Token::SeqEnd,
+            ],
+        );
+
+        let value = Value::Null;
+        assert_tokens(&value, &[Token::Seq { len: Some(1) }, Token::U8(0), Token::SeqEnd]);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn asset_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        let asset_id =
+            AssetId::from_str("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8")
+                .unwrap();
+        let asset = Asset::Explicit(asset_id);
+        assert_tokens(
+            &asset.readable(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(1),
+                Token::Str("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8"),
+                Token::SeqEnd,
+            ],
+        );
+        assert_tokens(
+            &asset.compact(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(1),
+                Token::Bytes(&[
+                    248, 11, 176, 3, 143, 72, 34, 67, 32, 47, 11, 45, 207, 136, 217, 180, 231, 249,
+                    48, 164, 138, 63, 205, 192, 3, 175, 118, 177, 249, 214, 14, 99,
+                ]),
+                Token::SeqEnd,
+            ],
+        );
+
+        let asset = Asset::from_commitment(&ASSET_COMMITMENT1).unwrap();
+        assert_tokens(
+            &asset.readable(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Str("0a0101010101010101010101010101010101010101010101010101010101010101"),
+                Token::SeqEnd,
+            ],
+        );
+        assert_tokens(
+            &asset.compact(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Bytes(&ASSET_COMMITMENT1),
+                Token::SeqEnd,
+            ],
+        );
+
+        let asset = Asset::Null;
+        assert_tokens(&asset, &[Token::Seq { len: Some(1) }, Token::U8(0), Token::SeqEnd]);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    #[rustfmt::skip]
+    fn nonce_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        let nonce = Nonce::Explicit([
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        ]);
+        assert_tokens(
+            &nonce,
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(1),
+                Token::Tuple { len: 32 },
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::TupleEnd,
+                Token::SeqEnd
+            ]
+        );
+
+        let nonce = Nonce::from_commitment(&NONCE_COMMITMENT1).unwrap();
+        assert_tokens(
+            &nonce.readable(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Str(
+                    "020101010101010101010101010101010101010101010101010101010101010101"
+                ),
+                Token::SeqEnd
+            ]
+        );
+        assert_tokens(
+            &nonce.compact(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::U8(2),
+                Token::Tuple { len: 33 },
+                Token::U8(2), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1), Token::U8(1), Token::U8(1), Token::U8(1),
+                Token::U8(1),
+                Token::TupleEnd,
+                Token::SeqEnd
+            ]
+        );
+
+        let nonce = Nonce::Null;
+        assert_tokens(
+            &nonce,
+            &[
+                Token::Seq { len: Some(1) },
+                Token::U8(0),
+                Token::SeqEnd
+            ]
+        );
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn bf_serde() {
+        use std::str::FromStr;
+
+        use serde_json;
+
+        let abf_str = "a5b3d111cdaa5fc111e2723df4caf315864f25fb4610cc737f10d5a55cd4096f";
+        let abf_str_quoted = format!("\"{}\"", abf_str);
+        let abf_from_serde: AssetBlindingFactor = serde_json::from_str(&abf_str_quoted).unwrap();
+        let abf_from_str = AssetBlindingFactor::from_str(abf_str).unwrap();
+        assert_eq!(abf_from_serde, abf_from_str);
+        assert_eq!(abf_str_quoted, serde_json::to_string(&abf_from_serde).unwrap());
+
+        let vbf_str = "e36a4de359469f547571d117bc5509fb74fba73c84b0cdd6f4edfa7ff7fa457d";
+        let vbf_str_quoted = format!("\"{}\"", vbf_str);
+        let vbf_from_serde: ValueBlindingFactor = serde_json::from_str(&vbf_str_quoted).unwrap();
+        let vbf_from_str = ValueBlindingFactor::from_str(vbf_str).unwrap();
+        assert_eq!(vbf_from_serde, vbf_from_str);
+        assert_eq!(vbf_str_quoted, serde_json::to_string(&vbf_from_serde).unwrap());
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_value_bincode_be() {
+        let value = Value::Explicit(500);
+        let bytes = bincode::serialize(&value).unwrap();
+        let decoded: Value = bincode::deserialize(&bytes).unwrap();
+        assert_eq!(value, decoded);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_value_bincode_le() {
+        use bincode::Options;
+        let value = Value::Explicit(500);
+        let bytes =
+            bincode::DefaultOptions::default().with_little_endian().serialize(&value).unwrap();
+        let decoded: Value =
+            bincode::DefaultOptions::default().with_little_endian().deserialize(&bytes).unwrap();
+        assert_eq!(value, decoded);
+    }
+}
diff --git a/src/confidential/nonce.rs b/src/confidential/nonce.rs
new file mode 100644
index 00000000..12310e0c
--- /dev/null
+++ b/src/confidential/nonce.rs
@@ -0,0 +1,361 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Confiential Nonces
+
+use core::fmt;
+use std::io;
+
+use secp256k1_zkp::rand::{CryptoRng, RngCore};
+use secp256k1_zkp::{self, PublicKey, Secp256k1, SecretKey, Signing};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::CommitmentEncoder;
+use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
+use crate::hashes::sha256d;
+
+type ExplicitInner = [u8; 32];
+type ConfInner = PublicKey;
+
+const EXPLICIT_LEN: usize = 32;
+const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
+const CONF_PREFIX_1: u8 = 0x02;
+const CONF_PREFIX_2: u8 = 0x03;
+
+/// A CT commitment to an output nonce (i.e. a public key)
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub enum Nonce {
+    /// No value
+    #[default]
+    Null,
+    /// There should be no such thing as an "explicit nonce", but Elements will deserialize
+    /// such a thing (and insists that its size be 32 bytes). So we stick a 32-byte type here
+    /// that implements all the traits we need.
+    Explicit(ExplicitInner),
+    /// Nonce is committed
+    Confidential(ConfInner),
+}
+
+impl Nonce {
+    /// Create nonce commitment.
+    pub fn new_confidential<R: RngCore + CryptoRng, C: Signing>(
+        rng: &mut R,
+        secp: &Secp256k1<C>,
+        receiver_blinding_pk: &ConfInner,
+    ) -> (Self, SecretKey) {
+        let ephemeral_sk = SecretKey::new(rng);
+        Self::with_ephemeral_sk(secp, ephemeral_sk, receiver_blinding_pk)
+    }
+
+    /// Similar to [`Self::new_confidential`], but with a given `ephemeral_sk`
+    /// instead of sampling it from rng.
+    pub fn with_ephemeral_sk<C: Signing>(
+        secp: &Secp256k1<C>,
+        ephemeral_sk: SecretKey,
+        receiver_blinding_pk: &ConfInner,
+    ) -> (Self, SecretKey) {
+        let sender_pk = ConfInner::from_secret_key(secp, &ephemeral_sk);
+        let shared_secret = Self::make_shared_secret(receiver_blinding_pk, &ephemeral_sk);
+        (Self::Confidential(sender_pk), shared_secret)
+    }
+
+    /// Calculate the shared secret.
+    pub fn shared_secret(&self, receiver_blinding_sk: &SecretKey) -> Option<SecretKey> {
+        match self {
+            Self::Confidential(sender_pk) =>
+                Some(Self::make_shared_secret(sender_pk, receiver_blinding_sk)),
+            _ => None,
+        }
+    }
+
+    /// Create the shared secret.
+    fn make_shared_secret(pk: &ConfInner, sk: &SecretKey) -> SecretKey {
+        let xy = secp256k1_zkp::ecdh::shared_secret_point(pk, sk);
+        let shared_secret = {
+            // Yes, what follows is the compressed representation of a Bitcoin public key.
+            // However, this is more by accident then by design, see here: https://github.com/rust-bitcoin/rust-secp256k1/pull/255#issuecomment-744146282
+
+            let mut dh_secret = [0u8; CONFIDENTIAL_LEN];
+            dh_secret[0] = if xy.last().unwrap() % 2 == 0 { CONF_PREFIX_1 } else { CONF_PREFIX_2 };
+            dh_secret[1..].copy_from_slice(&xy[0..32]);
+
+            sha256d::Hash::hash(&dh_secret).to_byte_array()
+        };
+
+        SecretKey::from_slice(&shared_secret[..32]).expect("always has exactly 32 bytes")
+    }
+
+    /// Serialized length, in bytes
+    pub fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 1 + EXPLICIT_LEN,
+            Self::Confidential(..) => CONFIDENTIAL_LEN,
+        }
+    }
+
+    /// Create from commitment.
+    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
+        Ok(Self::Confidential(
+            ConfInner::from_slice(bytes).map_err(secp256k1_zkp::Error::Upstream)?,
+        ))
+    }
+
+    /// Check if the object is null.
+    pub fn is_null(&self) -> bool { matches!(*self, Self::Null) }
+
+    /// Check if the object is explicit.
+    pub fn is_explicit(&self) -> bool { matches!(*self, Self::Explicit(_)) }
+
+    /// Check if the object is confidential.
+    pub fn is_confidential(&self) -> bool { matches!(*self, Self::Confidential(_)) }
+
+    /// Returns the explicit inner value.
+    /// Returns [None] if [`Self::is_explicit`] returns false.
+    pub fn explicit(&self) -> Option<ExplicitInner> {
+        match *self {
+            Self::Explicit(i) => Some(i),
+            _ => None,
+        }
+    }
+
+    /// Returns the confidential commitment in case of a confidential value.
+    /// Returns [None] if [`Self::is_confidential`] returns false.
+    pub fn commitment(&self) -> Option<ConfInner> {
+        match *self {
+            Self::Confidential(i) => Some(i),
+            _ => None,
+        }
+    }
+}
+
+impl From<ConfInner> for Nonce {
+    fn from(from: ConfInner) -> Self { Self::Confidential(from) }
+}
+
+impl fmt::Display for Nonce {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Null => f.write_str("null"),
+            Self::Explicit(n) => {
+                for b in &n {
+                    write!(f, "{:02x}", b)?;
+                }
+                Ok(())
+            }
+            Self::Confidential(pk) => write!(f, "{:02x}", pk),
+        }
+    }
+}
+
+impl Encodable for Nonce {
+    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
+        match *self {
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
+            Self::Explicit(n) => {
+                s.write_all(&[1u8])?;
+                s.write_all(&n)?;
+                Ok(1 + EXPLICIT_LEN)
+            }
+            Self::Confidential(commitment) => {
+                s.write_all(&commitment.serialize())?;
+                Ok(CONFIDENTIAL_LEN)
+            }
+        }
+    }
+}
+
+impl Decodable for Nonce {
+    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
+
+        match buf[0] {
+            0 => Ok(Self::Null),
+            1 => {
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(buf))
+            }
+            p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf)?))
+            }
+            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Nonce {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeSeq;
+
+        let seq_len = match *self {
+            Self::Null => 1,
+            Self::Explicit(_) | Self::Confidential(_) => 2,
+        };
+        let mut seq = s.serialize_seq(Some(seq_len))?;
+
+        match *self {
+            Self::Null => seq.serialize_element(&0u8)?,
+            Self::Explicit(n) => {
+                seq.serialize_element(&1u8)?;
+                seq.serialize_element(&n)?;
+            }
+            Self::Confidential(commitment) => {
+                seq.serialize_element(&2u8)?;
+                seq.serialize_element(&commitment)?;
+            }
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Nonce {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde::de::{Error, SeqAccess, Visitor};
+        struct CommitVisitor;
+
+        impl<'de> Visitor<'de> for CommitVisitor {
+            type Value = Nonce;
+
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("a committed value")
+            }
+
+            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Nonce, A::Error> {
+                let prefix = access.next_element::<u8>()?;
+                match prefix {
+                    Some(0) => Ok(Self::Value::Null),
+                    Some(1) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Explicit(x)),
+                        None => Err(A::Error::custom("missing explicit nonce")),
+                    },
+                    Some(2) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Confidential(x)),
+                        None => Err(A::Error::custom("missing nonce")),
+                    },
+                    _ => Err(A::Error::custom("wrong or missing prefix")),
+                }
+            }
+        }
+
+        d.deserialize_seq(CommitVisitor)
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Nonce`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Nonce {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit32(Some(1), id),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Nonce`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Nonce),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Nonce::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Nonce::Explicit(bytes)))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Nonce::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Nonce`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(bitcoin::secp256k1::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/confidential/range_proof.rs b/src/confidential/range_proof.rs
new file mode 100644
index 00000000..441b8c4f
--- /dev/null
+++ b/src/confidential/range_proof.rs
@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Range Proofs
+
+use core::convert::TryInto;
+use core::fmt;
+use std::io;
+
+use secp256k1_zkp::rand::{CryptoRng, RngCore};
+use secp256k1_zkp::{self, Generator, PedersenCommitment, Secp256k1, SecretKey, Signing, Tweak};
+#[cfg(feature = "serde")]
+use serde::{Deserializer, Serializer};
+
+use crate::confidential::ValueBlindingFactor;
+use crate::{encode, encoding};
+
+/// A range proof, which represents a proof that a confidential value lies within
+/// some range (typically `[0, 2^64)`).
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct RangeProof {
+    inner: Option<Box<secp256k1_zkp::RangeProof>>,
+}
+
+impl RangeProof {
+    /// No range proof.
+    pub const EMPTY: Self = Self { inner: None };
+
+    /// Constructs a new [`RangeProof`].
+    #[allow(clippy::too_many_arguments)]
+    pub fn new<C: Signing>(
+        secp: &Secp256k1<C>,
+        min_value: u64,
+        commitment: PedersenCommitment,
+        value: u64,
+        commitment_blinding: Tweak,
+        message: &[u8],
+        additional_commitment: &[u8],
+        sk: SecretKey,
+        exp: i32,
+        min_bits: u8,
+        additional_generator: Generator,
+    ) -> Result<Self, secp256k1_zkp::Error> {
+        secp256k1_zkp::RangeProof::new(
+            secp,
+            min_value,
+            commitment,
+            value,
+            commitment_blinding,
+            message,
+            additional_commitment,
+            sk,
+            exp,
+            min_bits,
+            additional_generator,
+        )
+        .map(|inner| Self { inner: Some(Box::new(inner)) })
+    }
+
+    /// Parses a [`RangeProof`] from a byte slice (with no length prefix).
+    pub fn from_slice(sl: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
+        if sl.is_empty() {
+            Ok(Self { inner: None })
+        } else {
+            secp256k1_zkp::RangeProof::from_slice(sl)
+                .map(|inner| Self { inner: Some(Box::new(inner)) })
+        }
+    }
+
+    /// Outputs a [`RangeProof`] proving that a commitment matches an exact value.
+    pub fn blind_value_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
+        rng: &mut R,
+        secp: &Secp256k1<C>,
+        explicit_val: u64,
+        value_commit: PedersenCommitment,
+        asset_gen: Generator,
+        vbf: ValueBlindingFactor,
+    ) -> Result<Self, secp256k1_zkp::Error> {
+        secp256k1_zkp::RangeProof::new(
+            secp,
+            explicit_val,        // min_value
+            value_commit,        // value_commit
+            explicit_val,        // value
+            vbf.into_inner(),    // blinding factor
+            &[],                 // message
+            &[],                 // add commitment
+            SecretKey::new(rng), // nonce
+            -1,                  // exp
+            0,                   // min bits
+            asset_gen,           // additional gen
+        )
+        .map(|inner| Self { inner: Some(Box::new(inner)) })
+    }
+
+    /// Verifies a [`RangeProof`] proving that a commitment matches an exact value.
+    pub fn blind_value_proof_verify<C: secp256k1_zkp::Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        explicit_val: u64,
+        asset_gen: Generator,
+        value_commit: PedersenCommitment,
+    ) -> bool {
+        let Some(inner) = self.inner.as_deref() else {
+            return false;
+        };
+        if explicit_val == u64::MAX {
+            // FIXME upstream will panic on this input; we should be able to validate
+            //  proofs with this value.
+            return false;
+        }
+
+        let Ok(range) = inner.verify(secp, value_commit, &[], asset_gen) else {
+            return false;
+        };
+        range == (explicit_val..explicit_val + 1)
+    }
+
+    /// The length of the range proof (zero if it is empty/absent).
+    pub fn len(&self) -> usize { self.inner.as_deref().map_or(0, secp256k1_zkp::RangeProof::len) }
+
+    /// Whether the range proof is absent.
+    pub fn is_empty(&self) -> bool { self.inner.is_none() }
+
+    /// Serializes the range proof as a byte vector.
+    pub fn to_vec(&self) -> Vec<u8> {
+        match self.inner.as_deref() {
+            Some(prf) => secp256k1_zkp::RangeProof::serialize(prf),
+            None => Vec::new(),
+        }
+    }
+
+    /// Extracts the minimum value encoded in the range proof.
+    pub fn minimim_value(&self) -> Option<u64> {
+        // inefficient, consider implementing index on rangeproof
+        let prf = self.to_vec();
+        let byte0 = prf.first()?;
+
+        let has_nonzero_range = byte0 & 64 == 64;
+        let has_min = byte0 & 32 == 32;
+
+        if !has_min {
+            None
+        } else if has_nonzero_range {
+            let bytes: [u8; 8] = prf.get(2..10)?.try_into().ok()?;
+            Some(u64::from_be_bytes(bytes))
+        } else {
+            let bytes: [u8; 8] = prf.get(1..9)?.try_into().ok()?;
+            Some(u64::from_be_bytes(bytes))
+        }
+    }
+
+    /// Obtains a reference to the underlying secp256k1-zkp object.
+    pub fn as_ref(&self) -> Option<&secp256k1_zkp::RangeProof> { self.inner.as_deref() }
+}
+
+impl crate::encode::Encodable for RangeProof {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        self.to_vec().consensus_encode(e)
+    }
+}
+
+impl crate::encode::Decodable for RangeProof {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        let v = Vec::<u8>::consensus_decode(d)?;
+        if v.is_empty() {
+            Ok(Self { inner: None })
+        } else {
+            secp256k1_zkp::RangeProof::from_slice(&v)
+                .map(|inner| Self { inner: Some(Box::new(inner)) })
+                .map_err(encode::Error::Secp256k1zkp)
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for RangeProof {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.inner.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for RangeProof {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Option::<secp256k1_zkp::RangeProof>::deserialize(deserializer)
+            .map(|inner| Self { inner: inner.map(Box::new) })
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`RangeProof`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(super::PrefixedByteVecEncoder);
+}
+
+impl encoding::Encode for RangeProof {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(super::PrefixedByteVecEncoder::new(self.to_vec()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`RangeProof`] type.
+    #[derive(Default)]
+    pub struct Decoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`RangeProof`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        Decode(encoding::ByteVecDecoderError),
+        RangeProof(secp256k1_zkp::Error),
+    });
+
+    impl Decode for RangeProof {
+        fn convert_inner(v) -> Result<_, DecoderErrorInner> {
+            Self::Output::from_slice(&v).map_err(DecoderErrorInner::RangeProof)
+        }
+    }
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(..) => f.write_str("error decoding byte vector"),
+            Inner::RangeProof(..) => f.write_str("error decoding range proof"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::RangeProof(ref e) => Some(e),
+        }
+    }
+}
diff --git a/src/confidential/surjection_proof.rs b/src/confidential/surjection_proof.rs
new file mode 100644
index 00000000..9a9ceed5
--- /dev/null
+++ b/src/confidential/surjection_proof.rs
@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Surjection Proofs
+
+use core::fmt;
+use std::io;
+
+use secp256k1_zkp::rand::{CryptoRng, RngCore};
+use secp256k1_zkp::{self, Generator, Secp256k1, Signing, Tweak, ZERO_TWEAK};
+#[cfg(feature = "serde")]
+use serde::{Deserializer, Serializer};
+
+use crate::confidential::{AssetBlindingFactor, AssetId};
+use crate::{encode, encoding};
+
+/// A surjection proof, proving that an asset commitment commits to the same asset ID
+/// as a commitment from a given set.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct SurjectionProof {
+    inner: Option<Box<secp256k1_zkp::SurjectionProof>>,
+}
+
+impl SurjectionProof {
+    /// No surjection proof.
+    pub const EMPTY: Self = Self { inner: None };
+
+    /// Constructs a new [`SurjectionProof`].
+    pub fn new<R, C, S>(
+        secp: &Secp256k1<C>,
+        rng: &mut R,
+        asset: AssetId,
+        asset_bf: AssetBlindingFactor,
+        inputs: S,
+    ) -> Result<Self, secp256k1_zkp::Error>
+    where
+        R: RngCore + CryptoRng,
+        C: Signing,
+        S: AsRef<[(Generator, secp256k1_zkp::Tag, Tweak)]>,
+    {
+        secp256k1_zkp::SurjectionProof::new(
+            secp,
+            rng,
+            asset.into_tag(),
+            asset_bf.into_inner(),
+            inputs.as_ref(),
+        )
+        .map(|inner| Self { inner: Some(Box::new(inner)) })
+    }
+
+    /// Parses a [`SurjectionProof`] from a byte slice (with no length prefix).
+    pub fn from_slice(sl: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
+        if sl.is_empty() {
+            Ok(Self { inner: None })
+        } else {
+            secp256k1_zkp::SurjectionProof::from_slice(sl)
+                .map(|inner| Self { inner: Some(Box::new(inner)) })
+        }
+    }
+
+    /// Serializes the surjection proof as a byte vector.
+    pub fn to_vec(&self) -> Vec<u8> {
+        match self.inner.as_deref() {
+            Some(prf) => secp256k1_zkp::SurjectionProof::serialize(prf),
+            None => Vec::new(),
+        }
+    }
+
+    /// Outputs a [`SurjectionProof`] proving that an asset matches an exact asset ID.
+    pub fn blind_asset_proof<C: secp256k1_zkp::Signing, R: RngCore + CryptoRng>(
+        rng: &mut R,
+        secp: &Secp256k1<C>,
+        asset: AssetId,
+        abf: AssetBlindingFactor,
+    ) -> Result<Self, secp256k1_zkp::Error> {
+        let gen = Generator::new_unblinded(secp, asset.into_tag());
+        Self::new(secp, rng, asset, abf, [(gen, asset.into_tag(), ZERO_TWEAK)])
+    }
+
+    /// Verifies a [`SurjectionProof`] proving that an asset matches an exact asset ID.
+    pub fn blind_asset_proof_verify(
+        &self,
+        secp: &Secp256k1<secp256k1_zkp::All>,
+        asset: AssetId,
+        asset_commit: Generator,
+    ) -> bool {
+        let gen = Generator::new_unblinded(secp, asset.into_tag());
+        match self.inner.as_deref() {
+            Some(inner) => inner.verify(secp, asset_commit, &[gen]),
+            None => false,
+        }
+    }
+
+    /// The length of the range proof (zero if it is empty/absent).
+    pub fn len(&self) -> usize {
+        self.inner.as_deref().map_or(0, secp256k1_zkp::SurjectionProof::len)
+    }
+
+    /// Whether the surjectionproof is absent.
+    pub fn is_empty(&self) -> bool { self.inner.is_none() }
+
+    /// Obtains a reference to the underlying secp256k1-zkp object.
+    pub fn as_ref(&self) -> Option<&secp256k1_zkp::SurjectionProof> { self.inner.as_deref() }
+}
+
+impl crate::encode::Encodable for SurjectionProof {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        match self.inner.as_ref() {
+            Some(prf) => secp256k1_zkp::SurjectionProof::serialize(prf).consensus_encode(e),
+            None => <[u8]>::consensus_encode(&[], e),
+        }
+    }
+}
+
+impl crate::encode::Decodable for SurjectionProof {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        let v = Vec::<u8>::consensus_decode(d)?;
+        if v.is_empty() {
+            Ok(Self { inner: None })
+        } else {
+            secp256k1_zkp::SurjectionProof::from_slice(&v)
+                .map(|inner| Self { inner: Some(Box::new(inner)) })
+                .map_err(encode::Error::Secp256k1zkp)
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for SurjectionProof {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.inner.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SurjectionProof {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Option::<secp256k1_zkp::SurjectionProof>::deserialize(deserializer)
+            .map(|inner| Self { inner: inner.map(Box::new) })
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`SurjectionProof`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(super::PrefixedByteVecEncoder);
+}
+
+impl encoding::Encode for SurjectionProof {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(super::PrefixedByteVecEncoder::new(self.to_vec()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`SurjectionProof`] type.
+    #[derive(Default)]
+    pub struct Decoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`SurjectionProof`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        Decode(encoding::ByteVecDecoderError),
+        SurjectionProof(secp256k1_zkp::Error),
+    });
+
+    impl Decode for SurjectionProof {
+        fn convert_inner(v) -> Result<_, DecoderErrorInner> {
+            Self::Output::from_slice(&v).map_err(DecoderErrorInner::SurjectionProof)
+        }
+    }
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(..) => f.write_str("error decoding byte vector"),
+            Inner::SurjectionProof(..) => f.write_str("error decoding surjection proof"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::SurjectionProof(ref e) => Some(e),
+        }
+    }
+}
diff --git a/src/confidential/value.rs b/src/confidential/value.rs
new file mode 100644
index 00000000..930e20c3
--- /dev/null
+++ b/src/confidential/value.rs
@@ -0,0 +1,521 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Confiential Values
+
+use core::ops::{AddAssign, Neg};
+use core::{fmt, str};
+use std::io;
+
+use secp256k1_zkp::rand::Rng;
+use secp256k1_zkp::{
+    self, compute_adaptive_blinding_factor, CommitmentSecrets, Generator, PedersenCommitment,
+    Secp256k1, SecretKey, Signing, Tweak, ZERO_TWEAK,
+};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::CommitmentEncoder;
+use crate::confidential::AssetBlindingFactor;
+use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
+use crate::issuance::AssetId;
+
+type ExplicitInner = u64;
+type ConfInner = PedersenCommitment;
+
+const EXPLICIT_LEN: usize = 8;
+const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
+const CONF_PREFIX_1: u8 = 0x08;
+const CONF_PREFIX_2: u8 = 0x09;
+
+/// A CT commitment to an amount
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub enum Value {
+    /// No value
+    #[default]
+    Null,
+    /// Value is explicitly encoded
+    Explicit(ExplicitInner),
+    /// Value is committed
+    Confidential(ConfInner),
+}
+
+impl Value {
+    /// Create value commitment.
+    pub fn new_confidential<C: Signing>(
+        secp: &Secp256k1<C>,
+        value: u64,
+        asset: Generator,
+        bf: BlindingFactor,
+    ) -> Self {
+        Self::Confidential(ConfInner::new(secp, value, bf.0, asset))
+    }
+
+    /// Create value commitment from assetID, asset blinding factor,
+    /// value and value blinding factor
+    pub fn new_confidential_from_assetid<C: Signing>(
+        secp: &Secp256k1<C>,
+        value: u64,
+        asset: AssetId,
+        v_bf: BlindingFactor,
+        a_bf: AssetBlindingFactor,
+    ) -> Self {
+        let generator = Generator::new_blinded(secp, asset.into_tag(), a_bf.0);
+        let comm = ConfInner::new(secp, value, v_bf.0, generator);
+
+        Self::Confidential(comm)
+    }
+
+    /// Serialized length, in bytes
+    pub fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 1 + EXPLICIT_LEN,
+            Self::Confidential(..) => CONFIDENTIAL_LEN,
+        }
+    }
+
+    /// Create from commitment.
+    pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
+        Ok(Self::Confidential(ConfInner::from_slice(bytes)?))
+    }
+
+    /// Check if the object is null.
+    pub fn is_null(&self) -> bool { matches!(*self, Self::Null) }
+
+    /// Check if the object is explicit.
+    pub fn is_explicit(&self) -> bool { matches!(*self, Self::Explicit(_)) }
+
+    /// Check if the object is confidential.
+    pub fn is_confidential(&self) -> bool { matches!(*self, Self::Confidential(_)) }
+
+    /// Returns the explicit inner value.
+    /// Returns [None] if [`Self::is_explicit`] returns false.
+    pub fn explicit(&self) -> Option<ExplicitInner> {
+        match *self {
+            Self::Explicit(i) => Some(i),
+            _ => None,
+        }
+    }
+
+    /// Returns the confidential commitment in case of a confidential value.
+    /// Returns [None] if [`Self::is_confidential`] returns false.
+    pub fn commitment(&self) -> Option<ConfInner> {
+        match *self {
+            Self::Confidential(i) => Some(i),
+            _ => None,
+        }
+    }
+}
+
+impl From<ConfInner> for Value {
+    fn from(from: ConfInner) -> Self { Self::Confidential(from) }
+}
+
+impl fmt::Display for Value {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Null => f.write_str("null"),
+            Self::Explicit(n) => write!(f, "{}", n),
+            Self::Confidential(commitment) => write!(f, "{:02x}", commitment),
+        }
+    }
+}
+
+impl Encodable for Value {
+    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
+        match *self {
+            Self::Null => {
+                s.write_all(&[0u8])?;
+                Ok(1)
+            }
+            Self::Explicit(n) => {
+                s.write_all(&[1u8])?;
+                s.write_all(&n.to_be_bytes())?;
+                Ok(1 + EXPLICIT_LEN)
+            }
+            Self::Confidential(commitment) => {
+                s.write_all(&commitment.serialize())?;
+                Ok(CONFIDENTIAL_LEN)
+            }
+        }
+    }
+}
+
+impl Decodable for Value {
+    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
+        let mut buf = [0u8; CONFIDENTIAL_LEN];
+        d.read_exact(&mut buf[0..1])?;
+
+        match buf[0] {
+            0 => Ok(Self::Null),
+            1 => {
+                let mut buf = [0; EXPLICIT_LEN];
+                d.read_exact(&mut buf)?;
+                Ok(Self::Explicit(u64::from_be_bytes(buf)))
+            }
+            p if p == CONF_PREFIX_1 || p == CONF_PREFIX_2 => {
+                d.read_exact(&mut buf[1..])?;
+                Ok(Self::Confidential(ConfInner::from_slice(&buf)?))
+            }
+            p => Err(encode::Error::InvalidConfidentialPrefix(p)),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Value {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeSeq;
+
+        let seq_len = match *self {
+            Self::Null => 1,
+            Self::Explicit(_) | Self::Confidential(_) => 2,
+        };
+        let mut seq = s.serialize_seq(Some(seq_len))?;
+
+        match *self {
+            Self::Null => seq.serialize_element(&0u8)?,
+            Self::Explicit(n) => {
+                seq.serialize_element(&1u8)?;
+                seq.serialize_element(&u64::swap_bytes(n))?;
+            }
+            Self::Confidential(commitment) => {
+                seq.serialize_element(&2u8)?;
+                seq.serialize_element(&commitment)?;
+            }
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Value {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde::de::{Error, SeqAccess, Visitor};
+        struct CommitVisitor;
+
+        impl<'de> Visitor<'de> for CommitVisitor {
+            type Value = Value;
+
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("a committed value")
+            }
+
+            fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Self::Value, A::Error> {
+                let prefix = access.next_element::<u8>()?;
+                match prefix {
+                    Some(0) => Ok(Self::Value::Null),
+                    Some(1) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Explicit(u64::swap_bytes(x))),
+                        None => Err(A::Error::custom("missing explicit value")),
+                    },
+                    Some(2) => match access.next_element()? {
+                        Some(x) => Ok(Self::Value::Confidential(x)),
+                        None => Err(A::Error::custom("missing pedersen commitment")),
+                    },
+                    _ => Err(A::Error::custom("wrong or missing prefix")),
+                }
+            }
+        }
+
+        d.deserialize_seq(CommitVisitor)
+    }
+}
+
+/// Blinding factor used for value commitments.
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct BlindingFactor(pub(crate) Tweak);
+
+impl BlindingFactor {
+    /// Generate random value blinding factor.
+    pub fn new<R: Rng>(rng: &mut R) -> Self { Self(Tweak::new(rng)) }
+
+    /// Parse a blinding factor from a 64-character hex string.
+    #[deprecated(since = "0.27.0", note = "use s.parse() instead")]
+    pub fn from_hex(s: &str) -> Result<Self, encode::Error> { s.parse() }
+
+    /// Create the value blinding factor of the last output of a transaction.
+    pub fn last<C: Signing>(
+        secp: &Secp256k1<C>,
+        value: u64,
+        abf: AssetBlindingFactor,
+        inputs: &[(u64, AssetBlindingFactor, Self)],
+        outputs: &[(u64, AssetBlindingFactor, Self)],
+    ) -> Self {
+        let set_a = inputs
+            .iter()
+            .map(|(value, abf, vbf)| CommitmentSecrets {
+                value: *value,
+                value_blinding_factor: vbf.0,
+                generator_blinding_factor: abf.into_inner(),
+            })
+            .collect::<Vec<_>>();
+        let set_b = outputs
+            .iter()
+            .map(|(value, abf, vbf)| CommitmentSecrets {
+                value: *value,
+                value_blinding_factor: vbf.0,
+                generator_blinding_factor: abf.into_inner(),
+            })
+            .collect::<Vec<_>>();
+
+        Self(compute_adaptive_blinding_factor(secp, value, abf.0, &set_a, &set_b))
+    }
+
+    /// Create from bytes.
+    pub fn from_slice(bytes: &[u8]) -> Result<Self, secp256k1_zkp::Error> {
+        Ok(Self(Tweak::from_slice(bytes)?))
+    }
+
+    /// Returns the inner value.
+    pub fn into_inner(self) -> Tweak { self.0 }
+
+    /// Get a unblinded/zero `AssetBlinding` factor
+    pub fn zero() -> Self { Self(ZERO_TWEAK) }
+}
+
+impl AddAssign for BlindingFactor {
+    fn add_assign(&mut self, other: Self) {
+        if self.0.as_ref() == &[0u8; 32] {
+            *self = other;
+        } else if other.0.as_ref() == &[0u8; 32] {
+            // nothing to do
+        } else {
+            // Since libsecp does not expose low level APIs
+            // for scalar arethematic, we need to abuse secret key
+            // operations for this
+            let sk2 = SecretKey::from_slice(self.into_inner().as_ref()).expect("Valid key");
+            let sk = SecretKey::from_slice(other.into_inner().as_ref()).expect("Valid key");
+            // The only reason that secret key addition can fail
+            // is when the keys add up to zero since we have already checked
+            // keys are in valid secret keys
+            match sk.add_tweak(&sk2.into()) {
+                Ok(sk_tweaked) =>
+                    *self = Self::from_slice(sk_tweaked.as_ref()).expect("Valid Tweak"),
+                Err(_) => *self = Self::zero(),
+            }
+        }
+    }
+}
+
+impl Neg for BlindingFactor {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        if self.0.as_ref() == &[0u8; 32] {
+            self
+        } else {
+            let sk = SecretKey::from_slice(self.into_inner().as_ref()).expect("Valid key").negate();
+            Self::from_slice(sk.as_ref()).expect("Valid Tweak")
+        }
+    }
+}
+
+impl core::borrow::Borrow<[u8]> for BlindingFactor {
+    fn borrow(&self) -> &[u8] { &self.0[..] }
+}
+
+hex::impl_fmt_traits! {
+    #[display_backward(true)]
+    impl fmt_traits for BlindingFactor {
+        const LENGTH: usize = 32;
+    }
+}
+
+impl str::FromStr for BlindingFactor {
+    type Err = encode::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut slice: [u8; 32] = hex::decode_to_array(s)?;
+        slice.reverse();
+
+        let inner = Tweak::from_inner(slice)?;
+        Ok(Self(inner))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for BlindingFactor {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        if s.is_human_readable() {
+            s.collect_str(&self)
+        } else {
+            s.serialize_bytes(&self.0[..])
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for BlindingFactor {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        if d.is_human_readable() {
+            struct HexVisitor;
+
+            impl ::serde::de::Visitor<'_> for HexVisitor {
+                type Value = BlindingFactor;
+
+                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
+                        hex.parse().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,
+                {
+                    v.parse().map_err(E::custom)
+                }
+            }
+
+            d.deserialize_str(HexVisitor)
+        } else {
+            struct BytesVisitor;
+
+            impl ::serde::de::Visitor<'_> for BytesVisitor {
+                type Value = BlindingFactor;
+
+                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                    formatter.write_str("a bytestring")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: ::serde::de::Error,
+                {
+                    use core::convert::TryFrom;
+
+                    match <[u8; 32]>::try_from(v) {
+                        Ok(ret) => {
+                            let inner = Tweak::from_inner(ret).map_err(E::custom)?;
+                            Ok(BlindingFactor(inner))
+                        }
+                        Err(_) => Err(E::invalid_length(v.len(), &stringify!($len))),
+                    }
+                }
+            }
+
+            d.deserialize_bytes(BytesVisitor)
+        }
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Asset`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Value {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit8(Some(1), id.to_be_bytes()),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Value`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Value),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Value::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Value::Explicit(u64::from_be_bytes(bytes))))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Value::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Value`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(secp256k1_zkp::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/dynafed.rs b/src/dynafed.rs
index 15aabb8d..c2f0227c 100644
--- a/src/dynafed.rs
+++ b/src/dynafed.rs
@@ -16,60 +16,62 @@
 
 use std::{fmt, io};
 
-use bitcoin;
-use bitcoin::hashes::{Hash, sha256, sha256d};
+use hex::DisplayHex as _;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "serde")]
 use serde::ser::{SerializeSeq, SerializeStruct};
 
 use crate::encode::{self, Encodable, Decodable};
+use crate::hashes::sha256d;
 use crate::Script;
 
-/// ad-hoc struct to fmt in hex
-struct HexBytes<'a>(&'a [u8]);
-impl<'a> fmt::Display for HexBytes<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        bitcoin::hashes::hex::format_hex(&self.0[..], f)
-    }
+impl_sha256_midstate_wrapper! {
+    /// The Merkle root of a set of dynafed parameters.
+    pub struct ParamsRoot([u8; 32]);
 }
-impl<'a> fmt::Debug for HexBytes<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self, f)
-    }
+
+impl_sha256_midstate_wrapper! {
+    /// A hash of elided dynafed parameter data.
+    pub struct ElidedRoot([u8; 32]);
 }
+
+/// ad-hoc struct to fmt in hex
 #[cfg(feature = "serde")]
-impl<'a> Serialize for HexBytes<'a> {
+struct HexBytes<'a>(&'a [u8]);
+#[cfg(feature = "serde")]
+impl Serialize for HexBytes<'_> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
-            s.collect_str(self)
+            s.collect_str(&self.0.as_hex())
         } else {
-            s.serialize_bytes(&self.0[..])
+            s.serialize_bytes(self.0)
         }
     }
 }
 
 /// ad-hoc struct to fmt in hex
 struct HexBytesArray<'a>(&'a [Vec<u8>]);
-impl<'a> fmt::Display for HexBytesArray<'a> {
+impl fmt::Display for HexBytesArray<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "[")?;
         for (i, e) in self.0.iter().enumerate() {
-            if i != 0 {
-                write!(f, ", ")?;
+            if i == 0 {
+                write!(f, "{}", e.as_hex())?;
+            } else {
+                write!(f, ", {}", e.as_hex())?;
             }
-            bitcoin::hashes::hex::format_hex(&e[..], f)?;
         }
         write!(f, "]")
     }
 }
-impl<'a> fmt::Debug for HexBytesArray<'a> {
+impl fmt::Debug for HexBytesArray<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self, f)
     }
 }
 #[cfg(feature = "serde")]
-impl<'a> Serialize for HexBytesArray<'a> {
+impl Serialize for HexBytesArray<'_> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         let mut seq = s.serialize_seq(Some(self.0.len()))?;
         for b in self.0 {
@@ -83,24 +85,41 @@ impl<'a> Serialize for HexBytesArray<'a> {
 #[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct FullParams {
     /// "scriptPubKey" used for block signing
-    signblockscript: Script,
+    pub signblockscript: Script,
     /// Maximum, in bytes, of the size of a blocksigning witness
-    signblock_witness_limit: u32,
+    pub signblock_witness_limit: u32,
     /// Untweaked `scriptPubKey` used for pegins
-    fedpeg_program: bitcoin::Script,
+    pub fedpeg_program: bitcoin::ScriptBuf,
     /// For v0 fedpeg programs, the witness script of the untweaked
     /// pegin address. For future versions, this data has no defined
     /// meaning and will be considered "anyone can spend".
-    fedpegscript: Vec<u8>,
+    pub fedpegscript: Vec<u8>,
     /// "Extension space" used by Liquid for PAK key entries
-    extension_space: Vec<Vec<u8>>,
+    pub extension_space: Vec<Vec<u8>>,
 }
 
 impl FullParams {
+    /// Construct a set of `FullParams`
+    pub fn new(
+        signblockscript: Script,
+        signblock_witness_limit: u32,
+        fedpeg_program: bitcoin::ScriptBuf,
+        fedpegscript: Vec<u8>,
+        extension_space: Vec<Vec<u8>>,
+    ) -> Self {
+        Self {
+            signblockscript,
+            signblock_witness_limit,
+            fedpeg_program,
+            fedpegscript,
+            extension_space,
+        }
+    }
+
     /// Return the `extra root` of this params.
     /// The extra root commits to the consensus parameters unrelated to
     /// blocksigning: `fedpeg_program`, `fedpegscript` and `extension_space`.
-    fn extra_root(&self) -> sha256::Midstate {
+    fn extra_root(&self) -> ElidedRoot {
         fn serialize_hash<E: Encodable>(obj: &E) -> sha256d::Hash {
             let mut engine = sha256d::Hash::engine();
             obj.consensus_encode(&mut engine).expect("engines don't error");
@@ -108,15 +127,15 @@ impl FullParams {
         }
 
         let leaves = [
-            serialize_hash(&self.fedpeg_program).into_inner(),
-            serialize_hash(&self.fedpegscript).into_inner(),
-            serialize_hash(&self.extension_space).into_inner(),
+            serialize_hash(&self.fedpeg_program).to_byte_array(),
+            serialize_hash(&self.fedpegscript).to_byte_array(),
+            serialize_hash(&self.extension_space).to_byte_array(),
         ];
-        crate::fast_merkle_root::fast_merkle_root(&leaves[..])
+        ElidedRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]))
     }
 
-    /// Calculate the root of this [FullParams].
-    pub fn calculate_root(&self) -> sha256::Midstate {
+    /// Calculate the root of this [`FullParams`].
+    pub fn calculate_root(&self) -> ParamsRoot {
         fn serialize_hash<E: Encodable>(obj: &E) -> sha256d::Hash {
             let mut engine = sha256d::Hash::engine();
             obj.consensus_encode(&mut engine).expect("engines don't error");
@@ -124,19 +143,19 @@ impl FullParams {
         }
 
         let leaves = [
-            serialize_hash(&self.signblockscript).into_inner(),
-            serialize_hash(&self.signblock_witness_limit).into_inner(),
+            serialize_hash(&self.signblockscript).to_byte_array(),
+            serialize_hash(&self.signblock_witness_limit).to_byte_array(),
         ];
         let compact_root = crate::fast_merkle_root::fast_merkle_root(&leaves[..]);
 
         let leaves = [
-            compact_root.into_inner(),
-            self.extra_root().into_inner(),
+            compact_root.to_parts().0,
+            self.extra_root().to_byte_array(),
         ];
-        crate::fast_merkle_root::fast_merkle_root(&leaves[..])
+        ParamsRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]))
     }
 
-    /// Turns paramers into compact parameters.
+    /// Turns parameters into compact parameters.
     /// This returns self for compact params and [None] for null ones.
     pub fn into_compact(self) -> Params {
         Params::Compact {
@@ -146,13 +165,13 @@ impl FullParams {
         }
     }
 
-    /// Format for [fmt::Debug].
+    /// Format for [`fmt::Debug`].
     fn fmt_debug(&self, f: &mut fmt::Formatter, name: &'static str) -> fmt::Result {
         let mut s = f.debug_struct(name);
-        s.field("signblockscript", &HexBytes(&self.signblockscript[..]));
+        s.field("signblockscript", &self.signblockscript[..].as_hex());
         s.field("signblock_witness_limit", &self.signblock_witness_limit);
-        s.field("fedpeg_program", &HexBytes(&self.fedpeg_program[..]));
-        s.field("fedpegscript", &HexBytes(&self.fedpegscript[..]));
+        s.field("fedpeg_program", &self.fedpeg_program.as_bytes().as_hex());
+        s.field("fedpegscript", &self.fedpegscript[..].as_hex());
         s.field("extension_space", &HexBytesArray(&self.extension_space));
         s.finish()
     }
@@ -199,10 +218,11 @@ impl Decodable for FullParams {
     }
 }
 
-/// Dynamic federations paramaters, as encoded in a block header
-#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
+/// Dynamic federations parameters, as encoded in a block header
+#[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub enum Params {
     /// Null entry, used to signal "no vote" as a proposal
+    #[default]
     Null,
     /// Compact params where the fedpeg data and extension space
     /// are not included, and are assumed to be equal to the values
@@ -213,7 +233,7 @@ pub enum Params {
         /// Maximum, in bytes, of the size of a blocksigning witness
         signblock_witness_limit: u32,
         /// Merkle root of extra data
-        elided_root: sha256::Midstate,
+        elided_root: ElidedRoot,
     },
     /// Full dynamic federations parameters
     Full(FullParams),
@@ -225,7 +245,7 @@ impl fmt::Debug for Params {
             Params::Null => write!(f, "Null"),
             Params::Compact { signblockscript, signblock_witness_limit, elided_root } => {
                 let mut s = f.debug_struct("Compact");
-                s.field("signblockscript", &HexBytes(&signblockscript[..]));
+                s.field("signblockscript", &signblockscript[..].as_hex());
                 s.field("signblock_witness_limit", signblock_witness_limit);
                 s.field("elided_root", elided_root);
                 s.finish()
@@ -236,7 +256,7 @@ impl fmt::Debug for Params {
 }
 
 impl Params {
-    /// Check whether this is [Params::Null].
+    /// Check whether this is [`Params::Null`].
     pub fn is_null(&self) -> bool {
         match *self {
             Params::Null => true,
@@ -245,7 +265,7 @@ impl Params {
         }
     }
 
-    /// Check whether this is [Params::Compact].
+    /// Check whether this is [`Params::Compact`].
     pub fn is_compact(&self) -> bool {
         match *self {
             Params::Null => false,
@@ -254,7 +274,7 @@ impl Params {
         }
     }
 
-    /// Check whether this is [Params::Full].
+    /// Check whether this is [`Params::Full`].
     pub fn is_full(&self) -> bool {
         match *self {
             Params::Null => false,
@@ -263,7 +283,7 @@ impl Params {
         }
     }
 
-    /// Get the signblockscript. Is [None] for [Null] params.
+    /// Get the signblockscript. Is [None] for [`Params::Null`] params.
     pub fn signblockscript(&self) -> Option<&Script> {
         match *self {
             Params::Null => None,
@@ -272,7 +292,7 @@ impl Params {
         }
     }
 
-    /// Get the signblock_witness_limit. Is [None] for [Null] params.
+    /// Get the `signblock_witness_limit`. Is [None] for [`Params::Null`] params.
     pub fn signblock_witness_limit(&self) -> Option<u32> {
         match *self {
             Params::Null => None,
@@ -281,8 +301,8 @@ impl Params {
         }
     }
 
-    /// Get the fedpeg_program. Is [None] for non-[Full] params.
-    pub fn fedpeg_program(&self) -> Option<&bitcoin::Script> {
+    /// Get the `fedpeg_program`. Is [None] for non-[`Params::Full`] params.
+    pub fn fedpeg_program(&self) -> Option<&bitcoin::ScriptBuf> {
         match *self {
             Params::Null => None,
             Params::Compact { .. } => None,
@@ -290,7 +310,7 @@ impl Params {
         }
     }
 
-    /// Get the fedpegscript. Is [None] for non-[Full] params.
+    /// Get the fedpegscript. Is [None] for non-[`Params::Full`] params.
     pub fn fedpegscript(&self) -> Option<&Vec<u8>> {
         match *self {
             Params::Null => None,
@@ -299,7 +319,7 @@ impl Params {
         }
     }
 
-    /// Get the extension_space. Is [None] for non-[Full] params.
+    /// Get the `extension_space`. Is [None] for non-[`Params::Full`] params.
     pub fn extension_space(&self) -> Option<&Vec<Vec<u8>>> {
         match *self {
             Params::Null => None,
@@ -308,8 +328,8 @@ impl Params {
         }
     }
 
-    /// Get the elided_root. Is [None] for non-[Compact] params.
-    pub fn elided_root(&self) -> Option<&sha256::Midstate> {
+    /// Get the `elided_root`. Is [None] for non-[`Params::Compact`] params.
+    pub fn elided_root(&self) -> Option<&ElidedRoot> {
         match *self {
             Params::Null => None,
             Params::Compact { ref elided_root, ..} => Some(elided_root),
@@ -320,16 +340,16 @@ impl Params {
     /// Return the `extra root` of this params.
     /// The extra root commits to the consensus parameters unrelated to
     /// blocksigning: `fedpeg_program`, `fedpegscript` and `extension_space`.
-    fn extra_root(&self) -> sha256::Midstate {
+    fn extra_root(&self) -> ElidedRoot {
         match *self {
-            Params::Null => sha256::Midstate::from_inner([0u8; 32]),
+            Params::Null => ElidedRoot::from_byte_array([0u8; 32]),
             Params::Compact { ref elided_root, .. } => *elided_root,
             Params::Full(ref f) => f.extra_root(),
         }
     }
 
     /// Calculate the root of this [Params].
-    pub fn calculate_root(&self) -> sha256::Midstate {
+    pub fn calculate_root(&self) -> ParamsRoot {
         fn serialize_hash<E: Encodable>(obj: &E) -> sha256d::Hash {
             let mut engine = sha256d::Hash::engine();
             obj.consensus_encode(&mut engine).expect("engines don't error");
@@ -337,20 +357,20 @@ impl Params {
         }
 
         if self.is_null() {
-            return sha256::Midstate::from_inner([0u8; 32]);
+            return ParamsRoot::from_byte_array([0u8; 32]);
         }
 
         let leaves = [
-            serialize_hash(self.signblockscript().unwrap()).into_inner(),
-            serialize_hash(&self.signblock_witness_limit().unwrap()).into_inner(),
+            serialize_hash(self.signblockscript().unwrap()).to_byte_array(),
+            serialize_hash(&self.signblock_witness_limit().unwrap()).to_byte_array(),
         ];
-        let compact_root = crate::fast_merkle_root::fast_merkle_root(&leaves[..]);
+        let compact_root = ElidedRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]));
 
         let leaves = [
-            compact_root.into_inner(),
-            self.extra_root().into_inner(),
+            compact_root.to_byte_array(),
+            self.extra_root().to_byte_array(),
         ];
-        crate::fast_merkle_root::fast_merkle_root(&leaves[..])
+        ParamsRoot::from_midstate(crate::fast_merkle_root::fast_merkle_root(&leaves[..]))
     }
 
     /// Get the full params when this params are full.
@@ -371,7 +391,7 @@ impl Params {
         }
     }
 
-    /// Turns paramers into compact parameters.
+    /// Turns parameters into compact parameters.
     /// This returns self for compact params and [None] for null ones.
     pub fn into_compact(self) -> Option<Params> {
         match self {
@@ -382,12 +402,6 @@ impl Params {
     }
 }
 
-impl Default for Params {
-    fn default() -> Params {
-        Params::Null
-    }
-}
-
 #[cfg(feature = "serde")]
 impl<'de> Deserialize<'de> for Params {
     fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
@@ -404,7 +418,7 @@ impl<'de> Deserialize<'de> for Params {
         }
         struct EnumVisitor;
 
-        impl<'de> de::Visitor<'de> for EnumVisitor {
+        impl de::Visitor<'_> for EnumVisitor {
             type Value = Enum;
 
             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -455,9 +469,7 @@ impl<'de> Deserialize<'de> for Params {
                             }
 
                             fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
-                                use bitcoin::hashes::hex::FromHex;
-
-                                Ok(HexBytes(FromHex::from_hex(v).map_err(E::custom)?))
+                                Ok(HexBytes(hex::decode_to_vec(v).map_err(E::custom)?))
                             }
 
                             fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Self::Value, E> {
@@ -606,7 +618,7 @@ impl Encodable for Params {
                 Encodable::consensus_encode(&1u8, &mut s)? +
                 Encodable::consensus_encode(signblockscript, &mut s)? +
                 Encodable::consensus_encode(signblock_witness_limit, &mut s)? +
-                Encodable::consensus_encode(&elided_root.into_inner(), &mut s)?
+                Encodable::consensus_encode(&elided_root.to_byte_array(), &mut s)?
             },
             Params::Full(ref f) => {
                 Encodable::consensus_encode(&2u8, &mut s)? +
@@ -624,7 +636,7 @@ impl Decodable for Params {
             1 => Ok(Params::Compact {
                 signblockscript: Decodable::consensus_decode(&mut d)?,
                 signblock_witness_limit: Decodable::consensus_decode(&mut d)?,
-                elided_root: sha256::Midstate::from_inner(Decodable::consensus_decode(&mut d)?),
+                elided_root: ElidedRoot::from_byte_array(Decodable::consensus_decode(&mut d)?),
             }),
             2 => Ok(Params::Full(Decodable::consensus_decode(&mut d)?)),
             _ => Err(encode::Error::ParseFailed(
@@ -638,9 +650,6 @@ impl Decodable for Params {
 mod tests {
     use std::fmt::{self, Write};
 
-    use bitcoin::hashes::hex::ToHex;
-    use bitcoin::hashes::sha256;
-
     use crate::{BlockHash, TxMerkleNode};
 
     use super::*;
@@ -676,29 +685,29 @@ mod tests {
 
         let signblockscript: Script = vec![1].into();
         let signblock_wl = 2;
-        let fp_program: bitcoin::Script = vec![3].into();
+        let fp_program: bitcoin::ScriptBuf = vec![3].into();
         let fp_script = vec![4];
         let ext = vec![vec![5, 6], vec![7]];
 
         let compact_entry = Params::Compact {
             signblockscript: signblockscript.clone(),
             signblock_witness_limit: signblock_wl,
-            elided_root: sha256::Midstate::from_inner([0; 32]),
+            elided_root: ElidedRoot::from_byte_array([0; 32]),
         };
         assert_eq!(
-            compact_entry.calculate_root().to_hex(),
+            format!("{:x}", compact_entry.calculate_root()),
             "f98f149fd11da6fbe26d0ee53cadd28372fa9eed2cb7080f41da7ca311531777"
         );
 
-        let full_entry = Params::Full(FullParams {
+        let full_entry = Params::Full(FullParams::new(
             signblockscript,
-            signblock_witness_limit: signblock_wl,
-            fedpeg_program: fp_program,
-            fedpegscript: fp_script,
-            extension_space: ext,
-        });
+            signblock_wl,
+            fp_program,
+            fp_script,
+            ext,
+        ));
         assert_eq!(
-            full_entry.calculate_root().to_hex(),
+            format!("{:x}", full_entry.calculate_root()),
             "8eb1b83cce69a3d8b0bfb7fbe77ae8f1d24b57a9cae047b8c0aba084ad878249"
         );
 
@@ -709,13 +718,13 @@ mod tests {
                 signblock_witness: vec![],
             },
             version: Default::default(),
-            prev_blockhash: BlockHash::all_zeros(),
-            merkle_root: TxMerkleNode::all_zeros(),
+            prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
+            merkle_root: TxMerkleNode::from_byte_array([0; 32]),
             time: Default::default(),
             height: Default::default(),
         };
         assert_eq!(
-            header.calculate_dynafed_params_root().unwrap().to_hex(),
+            format!("{:x}", header.calculate_dynafed_params_root().unwrap()),
             "113160f76dc17fe367a2def79aefe06feeea9c795310c9e88aeedc23e145982e"
         );
     }
diff --git a/src/encode.rs b/src/encode.rs
index 9d19e49a..578e2d87 100644
--- a/src/encode.rs
+++ b/src/encode.rs
@@ -16,30 +16,59 @@
 //!
 
 use std::io::Cursor;
-use std::{error, fmt, io, mem};
-use crate::hashes::{self, Hash};
+use std::{any, error, fmt, io, mem};
 
-use bitcoin::consensus::encode as btcenc;
-use bitcoin::hashes::sha256;
-use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
+use bitcoin::ScriptBuf;
+use hex::{DecodeFixedLengthBytesError, DecodeVariableLengthBytesError};
+use secp256k1_zkp::{self, Tweak};
 
-use crate::transaction::{Transaction, TxIn, TxOut};
+use crate::hashes::{sha256, Hash};
 use crate::pset;
 
 pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
-// Use the ReadExt/WriteExt traits as is from upstream
-pub use bitcoin::consensus::encode::{ReadExt, WriteExt};
-
 use crate::taproot::TapLeafHash;
 
+/// Adaptor to count bytes, used to implement Encodable/Decodable
+/// in terms of the new Encode/Decode traits.
+pub(crate) struct ByteCounter<W> {
+    inner: W,
+    count: usize,
+}
+
+impl<W> ByteCounter<W> {
+    pub(crate) fn new(inner: W) -> Self {
+        Self { inner, count: 0 }
+    }
+
+    pub(crate) fn into_count(self) -> usize {
+        self.count
+    }
+}
+
+impl<W> io::Write for ByteCounter<W>
+    where W: io::Write
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let res = self.inner.write(buf);
+        if let Ok(size) = res {
+            self.count += size;
+        }
+        res
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
 /// Encoding error
 #[derive(Debug)]
 pub enum Error {
     /// And I/O error
     Io(io::Error),
     /// A Bitcoin encoding error.
-    Bitcoin(btcenc::Error),
+    Bitcoin(bitcoin::consensus::encode::Error),
     /// Tried to allocate an oversized vector
     OversizedVectorAllocation {
         /// The capacity requested
@@ -59,10 +88,18 @@ pub enum Error {
     Secp256k1zkp(secp256k1_zkp::Error),
     /// Pset related Errors
     PsetError(pset::Error),
-    /// Hex parsing errors
-    HexError(hashes::hex::Error),
+    /// Hex fixed parsing errors
+    HexFixedError(DecodeFixedLengthBytesError),
+    /// Hex variable parsing errors
+    HexVariableError(DecodeVariableLengthBytesError),
     /// Got a time-based locktime when expecting a height-based one, or vice-versa
-    BadLockTime(crate::LockTime)
+    BadLockTime(crate::LockTime),
+    /// `VarInt` was encoded in a non-minimal way.
+    NonMinimalVarInt,
+    /// Error decoding a pegin witness.
+    PeginWitness(crate::PeginWitnessDecoderError),
+    /// Error decoding a script witness.
+    Witness(crate::WitnessDecoderError),
 }
 
 impl fmt::Display for Error {
@@ -73,8 +110,12 @@ impl fmt::Display for Error {
             Error::OversizedVectorAllocation {
                 requested: ref r,
                 max: ref m,
-            } => write!(f, "oversized vector allocation: requested {}, maximum {}", r, m),
-            Error::ParseFailed(ref e) => write!(f, "parse failed: {}", e),
+            } => write!(
+                f,
+                "oversized vector allocation: requested {}, maximum {}",
+                r, m
+            ),
+            Error::ParseFailed(e) => write!(f, "parse failed: {}", e),
             Error::UnexpectedEOF => write!(f, "unexpected EOF"),
             Error::InvalidConfidentialPrefix(p) => {
                 write!(f, "invalid confidential prefix: 0x{:02x}", p)
@@ -82,8 +123,12 @@ impl fmt::Display for Error {
             Error::Secp256k1(ref e) => write!(f, "{}", e),
             Error::Secp256k1zkp(ref e) => write!(f, "{}", e),
             Error::PsetError(ref e) => write!(f, "Pset Error: {}", e),
-            Error::HexError(ref e) => write!(f, "Hex error {}", e),
+            Error::HexFixedError(ref e) => write!(f, "Hex fixed error: {}", e),
+            Error::HexVariableError(ref e) => write!(f, "Hex variable error: {}", e),
             Error::BadLockTime(ref lt) => write!(f, "Invalid locktime {}", lt),
+            Error::NonMinimalVarInt => write!(f, "non-minimal varint"),
+            Self::PeginWitness(..) => f.write_str("error decoding pegin witness"),
+            Self::Witness(..) => f.write_str("error decoding script witness"),
         }
     }
 }
@@ -91,16 +136,16 @@ impl fmt::Display for Error {
 impl error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
-            Error::Bitcoin(ref e) => Some(e),
             Error::Secp256k1zkp(ref e) => Some(e),
+            Self::PeginWitness(ref e) => Some(e),
+            Self::Witness(ref e) => Some(e),
             _ => None,
         }
     }
 }
-
 #[doc(hidden)]
-impl From<btcenc::Error> for Error {
-    fn from(e: btcenc::Error) -> Error {
+impl From<bitcoin::consensus::encode::Error> for Error {
+    fn from(e: bitcoin::consensus::encode::Error) -> Error {
         Error::Bitcoin(e)
     }
 }
@@ -134,9 +179,16 @@ impl From<secp256k1_zkp::Error> for Error {
 }
 
 #[doc(hidden)]
-impl From<hashes::hex::Error> for Error {
-    fn from(e: hashes::hex::Error) -> Self {
-        Error::HexError(e)
+impl From<DecodeFixedLengthBytesError> for Error {
+    fn from(e: DecodeFixedLengthBytesError) -> Self {
+        Error::HexFixedError(e)
+    }
+}
+
+#[doc(hidden)]
+impl From<DecodeVariableLengthBytesError> for Error {
+    fn from(e: DecodeVariableLengthBytesError) -> Self {
+        Error::HexVariableError(e)
     }
 }
 
@@ -163,7 +215,7 @@ pub fn serialize<T: Encodable + ?Sized>(data: &T) -> Vec<u8> {
 
 /// Encode an object into a hex-encoded string
 pub fn serialize_hex<T: Encodable + ?Sized>(data: &T) -> String {
-    ::bitcoin::hashes::hex::ToHex::to_hex(&serialize(data)[..])
+    hex::DisplayHex::to_lower_hex_string(&serialize(data)[..])
 }
 
 /// Deserialize an object from a vector, will error if said deserialization
@@ -175,7 +227,9 @@ pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T, Error> {
     if consumed == data.len() {
         Ok(rv)
     } else {
-        Err(Error::ParseFailed("data not consumed entirely when explicitly deserializing"))
+        Err(Error::ParseFailed(
+            "data not consumed entirely when explicitly deserializing",
+        ))
     }
 }
 
@@ -189,55 +243,15 @@ pub fn deserialize_partial<T: Decodable>(data: &[u8]) -> Result<(T, usize), Erro
     Ok((rv, consumed))
 }
 
-impl Encodable for sha256::Midstate {
-    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
-        self.into_inner().consensus_encode(e)
-    }
-}
-
-impl Decodable for sha256::Midstate {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Self::from_inner(<[u8; 32]>::consensus_decode(d)?))
-    }
-}
-
-pub(crate) fn consensus_encode_with_size<S: io::Write>(data: &[u8], mut s: S) -> Result<usize, Error> {
-    let vi_len = bitcoin::VarInt(data.len() as u64).consensus_encode(&mut s)?;
-    s.emit_slice(&data)?;
+pub(crate) fn consensus_encode_with_size<S: crate::WriteExt>(
+    data: &[u8],
+    mut s: S,
+) -> Result<usize, Error> {
+    let vi_len = VarInt(data.len() as u64).consensus_encode(&mut s)?;
+    s.emit_slice(data)?;
     Ok(vi_len + data.len())
 }
 
-/// Implement Elements encodable traits for Bitcoin encodable types.
-macro_rules! impl_upstream {
-    ($type: ty) => {
-        impl Encodable for $type {
-            fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, Error> {
-                Ok(btcenc::Encodable::consensus_encode(self, &mut e)?)
-            }
-        }
-
-        impl Decodable for $type {
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                Ok(btcenc::Decodable::consensus_decode(&mut d)?)
-            }
-        }
-    };
-}
-impl_upstream!(u8);
-impl_upstream!(u32);
-impl_upstream!(u64);
-impl_upstream!([u8; 4]);
-impl_upstream!([u8; 32]);
-impl_upstream!(Box<[u8]>);
-impl_upstream!([u8; 33]);
-impl_upstream!(Vec<u8>);
-impl_upstream!(Vec<Vec<u8>>);
-impl_upstream!(btcenc::VarInt);
-impl_upstream!(crate::hashes::sha256d::Hash);
-impl_upstream!(bitcoin::Transaction);
-impl_upstream!(bitcoin::BlockHash);
-impl_upstream!(bitcoin::Script);
-
 // Specific locktime types (which appear in PSET/PSBT2 but not in rust-bitcoin PSBT)
 impl Encodable for crate::locktime::Height {
     fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
@@ -253,7 +267,6 @@ impl Decodable for crate::locktime::Height {
     }
 }
 
-
 impl Encodable for crate::locktime::Time {
     fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
         crate::LockTime::from(*self).consensus_encode(s)
@@ -268,136 +281,238 @@ impl Decodable for crate::locktime::Time {
     }
 }
 
+impl Encodable for crate::Witness {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
+        let mut counter = ByteCounter::new(e);
+        crate::encoding::encode_to_writer(self, &mut counter)?;
+        Ok(counter.into_count())
+    }
+}
 
-// Vectors
-macro_rules! impl_vec {
-    ($type: ty) => {
-        impl Encodable for Vec<$type> {
-            #[inline]
-            fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-                let mut len = 0;
-                len += btcenc::VarInt(self.len() as u64).consensus_encode(&mut s)?;
-                for c in self.iter() {
-                    len += c.consensus_encode(&mut s)?;
-                }
-                Ok(len)
-            }
+impl Decodable for crate::Witness {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        match crate::encoding::decode_from_read_unbuffered(d) {
+            Ok(wit) => Ok(wit),
+            Err(crate::encoding::ReadError::Io(e)) => Err(Error::Io(e)),
+            Err(crate::encoding::ReadError::Decode(e)) => Err(Error::Witness(e)),
         }
+    }
+}
 
-        impl Decodable for Vec<$type> {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                let len = btcenc::VarInt::consensus_decode(&mut d)?.0;
-                let byte_size = (len as usize)
-                    .checked_mul(mem::size_of::<$type>())
-                    .ok_or(self::Error::ParseFailed("Invalid length"))?;
-                if byte_size > MAX_VEC_SIZE {
-                    return Err(self::Error::OversizedVectorAllocation {
-                        requested: byte_size,
-                        max: MAX_VEC_SIZE,
-                    });
-                }
-                let mut ret = Vec::with_capacity(len as usize);
-                for _ in 0..len {
-                    ret.push(Decodable::consensus_decode(&mut d)?);
-                }
-                Ok(ret)
+/// A variable sized integer.
+pub struct VarInt(pub u64);
+impl Encodable for VarInt {
+    fn consensus_encode<W: crate::WriteExt>(&self, mut e: W) -> Result<usize, Error> {
+        Ok(e.emit_varint(self.0)?)
+    }
+}
+impl Decodable for VarInt {
+    fn consensus_decode<D: crate::ReadExt>(mut d: D) -> Result<Self, Error> {
+        Ok(VarInt(d.read_varint()?))
+    }
+}
+impl VarInt {
+    /// returns the byte size used if this var int is serialized
+    pub fn size(&self) -> usize {
+        match self.0 {
+            0..=0xFC => 1,
+            0xFD..=0xFFFF => 3,
+            0x10000..=0xFFFF_FFFF => 5,
+            _ => 9,
+        }
+    }
+}
+
+// Primitive types
+macro_rules! impl_int {
+    ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
+        impl Encodable for $ty {
+            fn consensus_encode<W: crate::WriteExt>(&self, mut w: W) -> Result<usize, Error> {
+                w.$meth_enc(*self)?;
+                Ok(mem::size_of::<$ty>())
+            }
+        }
+        impl Decodable for $ty {
+            fn consensus_decode<R: crate::ReadExt>(mut r: R) -> Result<Self, Error> {
+                crate::ReadExt::$meth_dec(&mut r)
             }
         }
     };
 }
-impl_vec!(TxIn);
-impl_vec!(TxOut);
-impl_vec!(Transaction);
-impl_vec!(TapLeafHash);
 
+impl_int!(u8, read_u8, emit_u8);
+impl_int!(u16, read_u16, emit_u16);
+impl_int!(u32, read_u32, emit_u32);
+impl_int!(u64, read_u64, emit_u64);
 
-macro_rules! impl_box_option {
-    ($type: ty) => {
-        impl Encodable for Option<Box<$type>> {
-            #[inline]
-            fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
-                match self {
-                    None => Vec::<u8>::new().consensus_encode(e),
-                    Some(v) => v.serialize().consensus_encode(e),
-                }
-            }
-        }
+impl Encodable for bitcoin::ScriptBuf {
+    fn consensus_encode<W: io::Write>(&self, w: W) -> Result<usize, Error> {
+        consensus_encode_with_size(self.as_script().as_bytes(), w)
+    }
+}
+impl Decodable for bitcoin::ScriptBuf {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        let bytes = Vec::<u8>::consensus_decode(d)?;
+        Ok(ScriptBuf::from_bytes(bytes))
+    }
+}
 
-        impl Decodable for Option<Box<$type>> {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                let v : Vec<u8> = Decodable::consensus_decode(&mut d)?;
-                if v.is_empty() {
-                    Ok(None)
-                } else {
-                    Ok(Some(Box::new(<$type>::from_slice(&v)?)))
-                }
+impl Encodable for hashes::sha256d::Hash {
+    fn consensus_encode<W: io::Write>(&self, mut w: W) -> Result<usize, Error> {
+        self.as_byte_array().consensus_encode(&mut w)
+    }
+}
+impl Decodable for hashes::sha256d::Hash {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        Ok(Self::from_byte_array(<[u8; 32]>::consensus_decode(d)?))
+    }
+}
+
+// Vectors
+impl<T: Encodable + any::Any> Encodable for [T] {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
+        if any::TypeId::of::<T>() == any::TypeId::of::<u8>() {
+            // SAFETY: checked that T is exactly u8, so &self, of type, &[T], is exactly &[u8]
+            let u8_slice = unsafe {
+                std::slice::from_raw_parts(self.as_ptr().cast::<u8>(), self.len())
+            };
+            consensus_encode_with_size(u8_slice, s)
+        } else {
+            let mut len = 0;
+            len += VarInt(self.len() as u64).consensus_encode(&mut s)?;
+            for c in self {
+                len += c.consensus_encode(&mut s)?;
             }
+            Ok(len)
         }
     }
 }
-// special implementations for elements only fields
-impl Encodable for Tweak {
-    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
-        self.as_ref().consensus_encode(e)
+
+impl<T: Encodable + any::Any> Encodable for Vec<T> {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
+        self[..].consensus_encode(s)
     }
 }
 
-impl Decodable for Tweak {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Tweak::from_inner(<[u8; 32]>::consensus_decode(d)?)?)
+impl<T: Encodable + any::Any> Encodable for Box<[T]> {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
+        self[..].consensus_encode(s)
     }
 }
 
-impl Encodable for RangeProof {
-    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
-        self.serialize().consensus_encode(e)
+impl<T: Decodable + any::Any> Decodable for Vec<T> {
+    #[inline]
+    fn consensus_decode<D: crate::ReadExt>(mut d: D) -> Result<Self, Error> {
+        if any::TypeId::of::<T>() == any::TypeId::of::<u8>() {
+            let s = VarInt::consensus_decode(&mut d)?.0 as usize;
+            if s > MAX_VEC_SIZE {
+                return Err(self::Error::OversizedVectorAllocation {
+                    requested: s,
+                    max: MAX_VEC_SIZE,
+                });
+            }
+            let mut v = vec![0; s];
+            d.read_slice(&mut v)?;
+            // SAFETY: checked that T is exactly u8, so v, of type, Vec<u8>, is exactly Vec<T>
+            unsafe {
+                Ok(std::mem::transmute::<Vec<u8>, Vec<T>>(v))
+            }
+        } else {
+            let len = VarInt::consensus_decode(&mut d)?.0;
+            let byte_size = (len as usize)
+                .checked_mul(mem::size_of::<T>())
+                .ok_or(self::Error::ParseFailed("Invalid length"))?;
+            if byte_size > MAX_VEC_SIZE {
+                return Err(self::Error::OversizedVectorAllocation {
+                    requested: byte_size,
+                    max: MAX_VEC_SIZE,
+                });
+            }
+            let mut ret = Vec::with_capacity(len as usize);
+            for _ in 0..len {
+                ret.push(Decodable::consensus_decode(&mut d)?);
+            }
+            Ok(ret)
+        }
     }
 }
 
-impl Decodable for RangeProof {
+impl<T: Decodable + any::Any> Decodable for Box<[T]> {
+    #[inline]
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(RangeProof::from_slice(&<Vec<u8>>::consensus_decode(d)?)?)
+        let v = Vec::<T>::consensus_decode(d)?;
+        Ok(v.into())
     }
 }
 
-impl Encodable for SurjectionProof {
+macro_rules! impl_array {
+    ( $size:literal ) => {
+        impl Encodable for [u8; $size] {
+            #[inline]
+            fn consensus_encode<W: crate::WriteExt>(
+                &self,
+                mut w: W,
+            ) -> core::result::Result<usize, Error> {
+                w.emit_slice(&self[..])?;
+                Ok($size)
+            }
+        }
+
+        impl Decodable for [u8; $size] {
+            #[inline]
+            fn consensus_decode<R: crate::ReadExt>(mut r: R) -> core::result::Result<Self, Error> {
+                let mut ret = [0; $size];
+                r.read_slice(&mut ret)?;
+                Ok(ret)
+            }
+        }
+    };
+}
+impl_array!(4);
+impl_array!(20);
+impl_array!(32);
+impl_array!(33);
+
+// special implementations for elements only fields
+impl Encodable for Tweak {
     fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
-        self.serialize().consensus_encode(e)
+        self.as_ref().consensus_encode(e)
     }
 }
 
-impl Decodable for SurjectionProof {
+impl Decodable for Tweak {
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(SurjectionProof::from_slice(&<Vec<u8>>::consensus_decode(d)?)?)
+        Ok(Tweak::from_inner(<[u8; 32]>::consensus_decode(d)?)?)
     }
 }
 
-
 impl Encodable for sha256::Hash {
     fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
-        self.into_inner().consensus_encode(s)
+        self.to_byte_array().consensus_encode(s)
     }
 }
 
 impl Decodable for sha256::Hash {
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(d)?))
+        Ok(Self::from_byte_array(
+            <<Self as Hash>::Bytes>::consensus_decode(d)?,
+        ))
     }
 }
 
 impl Encodable for TapLeafHash {
     fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
-        self.into_inner().consensus_encode(s)
+        self.to_byte_array().consensus_encode(s)
     }
 }
 
 impl Decodable for TapLeafHash {
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(d)?))
+        Ok(Self::from_byte_array(
+            <<Self as Hash>::Bytes>::consensus_decode(d)?,
+        ))
     }
 }
-
-impl_box_option!(RangeProof);
-impl_box_option!(SurjectionProof);
diff --git a/src/endian.rs b/src/endian.rs
index 6a009281..fec6eed9 100644
--- a/src/endian.rs
+++ b/src/endian.rs
@@ -20,6 +20,6 @@ mod tests {
 
     #[test]
     fn endianness_test() {
-        assert_eq!(u32_to_array_le(0xdeadbeef), [0xef, 0xbe, 0xad, 0xde]);
+        assert_eq!(u32_to_array_le(0xdead_beef), [0xef, 0xbe, 0xad, 0xde]);
     }
 }
diff --git a/src/error.rs b/src/error.rs
index 31d381ad..6957ee8a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,19 +2,15 @@
 
 pub use crate::parse::ParseIntError;
 
-/// Impls std::error::Error for the specified type with appropriate attributes, possibly returning
+/// Impls `std::error::Error` for the specified type with appropriate attributes, possibly returning
 /// source.
 macro_rules! impl_std_error {
     // No source available
     ($type:ty) => {
-        #[cfg(feature = "std")]
-        #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
         impl std::error::Error for $type {}
     };
     // Struct with $field as source
     ($type:ty, $field:ident) => {
-        #[cfg(feature = "std")]
-        #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
         impl std::error::Error for $type {
             fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
                 Some(&self.$field)
@@ -29,18 +25,11 @@ pub(crate) use impl_std_error;
 /// lost for no-std builds.
 macro_rules! write_err {
     ($writer:expr, $string:literal $(, $args:expr)*; $source:expr) => {
-        {   
-            #[cfg(feature = "std")]
-            {   
-                let _ = &$source;   // Prevents clippy warnings.
-                write!($writer, $string $(, $args)*)
-            }   
-            #[cfg(not(feature = "std"))]
-            {   
-                write!($writer, concat!($string, ": {}") $(, $args)*, $source)
-            }   
-        }   
-    }   
+        {
+            let _ = &$source;   // Prevents clippy warnings.
+            write!($writer, $string $(, $args)*)
+        }
+    }
 }
 pub(crate) use write_err;
 
diff --git a/src/ext.rs b/src/ext.rs
new file mode 100644
index 00000000..d70e1556
--- /dev/null
+++ b/src/ext.rs
@@ -0,0 +1,194 @@
+use std::io;
+
+use crate::encode;
+
+/// Extensions of `Write` to encode data as per Bitcoin consensus.
+pub trait WriteExt: io::Write {
+    /// Outputs a 64-bit unsigned integer.
+    fn emit_u64(&mut self, v: u64) -> Result<(), io::Error>;
+    /// Outputs a 32-bit unsigned integer.
+    fn emit_u32(&mut self, v: u32) -> Result<(), io::Error>;
+    /// Outputs a 16-bit unsigned integer.
+    fn emit_u16(&mut self, v: u16) -> Result<(), io::Error>;
+    /// Outputs an 8-bit unsigned integer.
+    fn emit_u8(&mut self, v: u8) -> Result<(), io::Error>;
+
+    /// Outputs a 64-bit signed integer.
+    fn emit_i64(&mut self, v: i64) -> Result<(), io::Error>;
+    /// Outputs a 32-bit signed integer.
+    fn emit_i32(&mut self, v: i32) -> Result<(), io::Error>;
+    /// Outputs a 16-bit signed integer.
+    fn emit_i16(&mut self, v: i16) -> Result<(), io::Error>;
+    /// Outputs an 8-bit signed integer.
+    fn emit_i8(&mut self, v: i8) -> Result<(), io::Error>;
+
+    /// Outputs a variable sized integer.
+    fn emit_varint(&mut self, v: u64) -> Result<usize, io::Error>;
+
+    /// Outputs a boolean.
+    fn emit_bool(&mut self, v: bool) -> Result<(), io::Error>;
+
+    /// Outputs a byte slice.
+    fn emit_slice(&mut self, v: &[u8]) -> Result<usize, io::Error>;
+}
+
+/// Extensions of `Read` to decode data as per Bitcoin consensus.
+pub trait ReadExt: io::Read {
+    /// Reads a 64-bit unsigned integer.
+    fn read_u64(&mut self) -> Result<u64, encode::Error>;
+    /// Reads a 32-bit unsigned integer.
+    fn read_u32(&mut self) -> Result<u32, encode::Error>;
+    /// Reads a 16-bit unsigned integer.
+    fn read_u16(&mut self) -> Result<u16, encode::Error>;
+    /// Reads an 8-bit unsigned integer.
+    fn read_u8(&mut self) -> Result<u8, encode::Error>;
+
+    /// Reads a 64-bit signed integer.
+    fn read_i64(&mut self) -> Result<i64, encode::Error>;
+    /// Reads a 32-bit signed integer.
+    fn read_i32(&mut self) -> Result<i32, encode::Error>;
+    /// Reads a 16-bit signed integer.
+    fn read_i16(&mut self) -> Result<i16, encode::Error>;
+    /// Reads an 8-bit signed integer.
+    fn read_i8(&mut self) -> Result<i8, encode::Error>;
+
+    /// Reads a variable sized integer.
+    fn read_varint(&mut self) -> Result<u64, encode::Error>;
+
+    /// Reads a boolean.
+    fn read_bool(&mut self) -> Result<bool, encode::Error>;
+
+    /// Reads a byte slice.
+    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), encode::Error>;
+}
+
+macro_rules! encoder_fn {
+    ($name:ident, $val_type:ty) => {
+        #[inline]
+        fn $name(&mut self, v: $val_type) -> core::result::Result<(), io::Error> {
+            self.write_all(&v.to_le_bytes())
+        }
+    };
+}
+
+macro_rules! decoder_fn {
+    ($name:ident, $val_type:ty, $byte_len: expr) => {
+        #[inline]
+        fn $name(&mut self) -> core::result::Result<$val_type, encode::Error> {
+            let mut val = [0; $byte_len];
+            self.read_exact(&mut val[..]).map_err(encode::Error::Io)?;
+            Ok(<$val_type>::from_le_bytes(val))
+        }
+    };
+}
+
+impl<W: io::Write + ?Sized> WriteExt for W {
+    encoder_fn!(emit_u64, u64);
+    encoder_fn!(emit_u32, u32);
+    encoder_fn!(emit_u16, u16);
+    encoder_fn!(emit_i64, i64);
+    encoder_fn!(emit_i32, i32);
+    encoder_fn!(emit_i16, i16);
+
+    #[inline]
+    fn emit_i8(&mut self, v: i8) -> Result<(), io::Error> {
+        self.write_all(&[v as u8])
+    }
+    #[inline]
+    fn emit_u8(&mut self, v: u8) -> Result<(), io::Error> {
+        self.write_all(&[v])
+    }
+    #[inline]
+    fn emit_bool(&mut self, v: bool) -> Result<(), io::Error> {
+        self.write_all(&[u8::from(v)])
+    }
+    #[inline]
+    fn emit_slice(&mut self, v: &[u8]) -> Result<usize, io::Error> {
+        self.write_all(v)?;
+        Ok(v.len())
+    }
+    #[inline]
+    fn emit_varint(&mut self, v: u64) -> Result<usize, io::Error> {
+        match v {
+            i @ 0..=0xFC => {
+                self.emit_u8(i as u8)?;
+                Ok(1)
+            }
+            i @ 0xFD..=0xFFFF => {
+                self.emit_u8(0xFD)?;
+                self.emit_u16(i as u16)?;
+                Ok(3)
+            }
+            i @ 0x10000..=0xFFFF_FFFF => {
+                self.emit_u8(0xFE)?;
+                self.emit_u32(i as u32)?;
+                Ok(5)
+            }
+            i => {
+                self.emit_u8(0xFF)?;
+                self.emit_u64(i)?;
+                Ok(9)
+            }
+        }
+    }
+}
+
+impl<R: io::Read + ?Sized> ReadExt for R {
+    decoder_fn!(read_u64, u64, 8);
+    decoder_fn!(read_u32, u32, 4);
+    decoder_fn!(read_u16, u16, 2);
+    decoder_fn!(read_i64, i64, 8);
+    decoder_fn!(read_i32, i32, 4);
+    decoder_fn!(read_i16, i16, 2);
+
+    #[inline]
+    fn read_u8(&mut self) -> Result<u8, encode::Error> {
+        let mut slice = [0u8; 1];
+        self.read_exact(&mut slice)?;
+        Ok(slice[0])
+    }
+    #[inline]
+    fn read_i8(&mut self) -> Result<i8, encode::Error> {
+        let mut slice = [0u8; 1];
+        self.read_exact(&mut slice)?;
+        Ok(slice[0] as i8)
+    }
+    #[inline]
+    fn read_bool(&mut self) -> Result<bool, encode::Error> {
+        ReadExt::read_i8(self).map(|bit| bit != 0)
+    }
+    #[inline]
+    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), encode::Error> {
+        self.read_exact(slice).map_err(encode::Error::Io)
+    }
+    #[inline]
+    fn read_varint(&mut self) -> Result<u64, encode::Error> {
+        match self.read_u8()? {
+            0xFF => {
+                let x = self.read_u64()?;
+                if x < 0x1_0000_0000 {
+                    Err(encode::Error::NonMinimalVarInt)
+                } else {
+                    Ok(x)
+                }
+            }
+            0xFE => {
+                let x = self.read_u32()?;
+                if x < 0x10000 {
+                    Err(encode::Error::NonMinimalVarInt)
+                } else {
+                    Ok(u64::from(x))
+                }
+            }
+            0xFD => {
+                let x = self.read_u16()?;
+                if x < 0xFD {
+                    Err(encode::Error::NonMinimalVarInt)
+                } else {
+                    Ok(u64::from(x))
+                }
+            }
+            n => Ok(u64::from(n)),
+        }
+    }
+}
diff --git a/src/fast_merkle_root.rs b/src/fast_merkle_root.rs
index 7cc384c6..7d7c5abe 100644
--- a/src/fast_merkle_root.rs
+++ b/src/fast_merkle_root.rs
@@ -12,7 +12,7 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
-use bitcoin::hashes::{sha256, Hash, HashEngine};
+use crate::hashes::{sha256, HashEngine};
 
 /// Calculate a single sha256 midstate hash of the given left and right leaves.
 #[inline]
@@ -20,15 +20,16 @@ fn sha256midstate(left: &[u8], right: &[u8]) -> sha256::Midstate {
     let mut engine = sha256::Hash::engine();
     engine.input(left);
     engine.input(right);
-    engine.midstate()
+    engine.midstate().expect("hashing exactly 64 bytes")
 }
 
 /// Compute the Merkle root of the give hashes using mid-state only.
+///
 /// The inputs must be byte slices of length 32.
 /// Note that the merkle root calculated with this method is not the same as the
 /// one computed by a normal SHA256(d) merkle root.
 pub fn fast_merkle_root(leaves: &[[u8; 32]]) -> sha256::Midstate {
-    let mut result_hash = Default::default();
+    let mut result_hash = sha256::Midstate::default();
     // Implementation based on ComputeFastMerkleRoot method in Elements Core.
     if leaves.is_empty() {
         return result_hash;
@@ -44,14 +45,14 @@ pub fn fast_merkle_root(leaves: &[[u8; 32]]) -> sha256::Midstate {
     let mut inner: [sha256::Midstate; 32] = Default::default();
     let mut count: u32 = 0;
     while (count as usize) < leaves.len() {
-        let mut temp_hash = sha256::Midstate::from_inner(leaves[count as usize]);
+        let mut temp_hash = sha256::Midstate::new(leaves[count as usize], 64);
         count += 1;
         // For each of the lower bits in count that are 0, do 1 step. Each
         // corresponds to an inner value that existed before processing the
         // current leaf, and each needs a hash to combine it.
         let mut level = 0;
         while count & (1u32 << level) == 0 {
-            temp_hash = sha256midstate(&inner[level][..], &temp_hash[..]);
+            temp_hash = sha256midstate(inner[level].as_parts().0, temp_hash.as_parts().0);
             level += 1;
         }
         // Store the resulting hash at inner position level.
@@ -80,7 +81,7 @@ pub fn fast_merkle_root(leaves: &[[u8; 32]]) -> sha256::Midstate {
         count += 1 << level;
         level += 1;
         while count & (1u32 << level) == 0 {
-            result_hash = sha256midstate(&inner[level][..], &result_hash[..]);
+            result_hash = sha256midstate(inner[level].as_parts().0, result_hash.as_parts().0);
             level += 1;
         }
     }
@@ -91,11 +92,15 @@ pub fn fast_merkle_root(leaves: &[[u8; 32]]) -> sha256::Midstate {
 #[cfg(test)]
 mod tests {
     use super::fast_merkle_root;
-    use bitcoin::hashes::hex::FromHex;
-    use bitcoin::hashes::sha256;
 
     #[test]
     fn test_fast_merkle_root() {
+        fn decode_hex(hex: &str) -> [u8; 32] {
+            let mut ret = hex::decode_to_array(hex).unwrap();
+            ret.reverse();
+            ret
+        }
+
         // unit test vectors from Elements Core
         let test_leaves = [
             "b66b041650db0f297b53f8d93c0e8706925bf3323f8c59c14a6fac37bfdcd06f",
@@ -115,9 +120,9 @@ mod tests {
         let mut leaves = vec![];
         for i in 0..4 {
             let root = fast_merkle_root(&leaves);
-            assert_eq!(root, FromHex::from_hex(&test_roots[i]).unwrap(), "root #{}", i);
-            leaves.push(sha256::Midstate::from_hex(&test_leaves[i]).unwrap().into_inner());
+            assert_eq!(root.to_parts().0, decode_hex(test_roots[i]), "root #{i}");
+            leaves.push(decode_hex(test_leaves[i]));
         }
-        assert_eq!(fast_merkle_root(&leaves), FromHex::from_hex(test_roots[4]).unwrap());
+        assert_eq!(fast_merkle_root(&leaves).to_parts().0, decode_hex(test_roots[4]));
     }
 }
diff --git a/src/genesis.rs b/src/genesis.rs
new file mode 100644
index 00000000..d10367eb
--- /dev/null
+++ b/src/genesis.rs
@@ -0,0 +1,268 @@
+// Rust Elements Library
+// Written by
+//   The Elements developers
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//! Helpers to calculate the genesis block for a given network.
+
+use bitcoin::secp256k1::impl_array_newtype;
+use crate::hashes::{sha256, HashEngine};
+use crate::opcodes::all::OP_RETURN;
+use crate::opcodes::OP_TRUE;
+use crate::{confidential, script, AssetId, Block, BlockExtData, BlockHash, BlockHeader, LockTime, Script, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness};
+use crate::{AssetBlindingNonce, AssetEntropy, AssetIssuance, ContractHash, OutPoint, Txid};
+use crate::confidential::Nonce;
+
+/// Parameters that influence chain consensus. The contents of the genesis block for a given network
+/// are defined by these values.
+#[derive(Clone, Debug)]
+pub struct NetworkParams {
+    /// The network identifier string that elementsd accepts as the `chain` config argument
+    pub network_id: String,
+    /// This network's Fedpeg script
+    pub fedpeg_script: Script,
+    /// This network's `sign_block_script`
+    pub sign_block_script: Script,
+    /// How many free coins are present in this network
+    pub initial_free_coins: u64,
+}
+
+impl NetworkParams {
+    /// New custom network params
+    pub fn new(
+        network_id: String,
+        fedpeg_script: Script,
+        sign_block_script: Script,
+        initial_free_coins: u64,
+    ) -> NetworkParams {
+        NetworkParams {
+            network_id,
+            fedpeg_script,
+            sign_block_script,
+            initial_free_coins,
+        }
+    }
+
+    /// Network params for Liquid mainnet
+    pub fn liquidv1() -> Self {
+        NetworkParams {
+            network_id: "liquidv1".to_string(),
+            // Can be verified at https://github.com/ElementsProject/elements/blob/27c2fb6b7de404908f9ef2eb5c98c9989d1ab8e4/src/chainparams.cpp#L1243
+            fedpeg_script: Script::from_hex_no_prefix("745c87635b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc40102102f8a00b269f8c5e59c67d36db3cdc11b11b21f64b4bffb2815e9100d9aa8daf072103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5f6702c00fb275522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb5368ae").expect("constant fedpeg script parse"),
+            // Can be verified at https://github.com/ElementsProject/elements/blob/27c2fb6b7de404908f9ef2eb5c98c9989d1ab8e4/src/chainparams.cpp#L1193
+            sign_block_script: Script::from_hex_no_prefix("5b21026a2a106ec32c8a1e8052e5d02a7b0a150423dbd9b116fc48d46630ff6e6a05b92102791646a8b49c2740352b4495c118d876347bf47d0551c01c4332fdc2df526f1a2102888bda53a424466b0451627df22090143bbf7c060e9eacb1e38426f6b07f2ae12102aee8967150dee220f613de3b239320355a498808084a93eaf39a34dcd62024852102d46e9259d0a0bb2bcbc461a3e68f34adca27b8d08fbe985853992b4b104e27412102e9944e35e5750ab621e098145b8e6cf373c273b7c04747d1aa020be0af40ccd62102f9a9d4b10a6d6c56d8c955c547330c589bb45e774551d46d415e51cd9ad5116321033b421566c124dfde4db9defe4084b7aa4e7f36744758d92806b8f72c2e943309210353dcc6b4cf6ad28aceb7f7b2db92a4bf07ac42d357adf756f3eca790664314b621037f55980af0455e4fb55aad9b85a55068bb6dc4740ea87276dc693f4598db45fa210384001daa88dabd23db878dbb1ce5b4c2a5fa72c3113e3514bf602325d0c37b8e21039056d089f2fe72dbc0a14780b4635b0dc8a1b40b7a59106325dd1bc45cc70493210397ab8ea7b0bf85bc7fc56bb27bf85e75502e94e76a6781c409f3f2ec3d1122192103b00e3b5b77884bf3cae204c4b4eac003601da75f96982ffcb3dcb29c5ee419b92103c1f3c0874cfe34b8131af34699589aacec4093399739ae352e8a46f80a6f68375fae").expect("constant sign_block_script parse"),
+            initial_free_coins: 0,
+        }
+    }
+
+    /// Network params for Liquid testnet
+    pub fn liquidtestnet() -> Self {
+        NetworkParams {
+            network_id: "liquidtestnet".to_string(),
+            fedpeg_script: script::Builder::new().push_opcode(OP_TRUE).into_script(),
+            // Can be verified at https://github.com/ElementsProject/elements/blob/27c2fb6b7de404908f9ef2eb5c98c9989d1ab8e4/src/chainparams.cpp#L1108
+            sign_block_script: Script::from_hex_no_prefix("51210217e403ddb181872c32a0cd468c710040b2f53d8cac69f18dad07985ee37e9a7151ae").expect("constant sign_block_script parse"),
+            initial_free_coins: 2_100_000_000_000_000,
+        }
+    }
+
+    /// Network params for a custom Elements network with defaults
+    pub fn custom_network(network_id: String, fedpeg_script: Option<Script>, sign_block_script: Option<Script>, initial_free_coins: Option<u64>) -> Self {
+        NetworkParams {
+            network_id,
+            fedpeg_script: fedpeg_script.unwrap_or_else(|| script::Builder::new().push_opcode(OP_TRUE).into_script()),
+            sign_block_script: sign_block_script.unwrap_or_else(|| script::Builder::new().push_opcode(OP_TRUE).into_script()),
+            initial_free_coins: initial_free_coins.unwrap_or(0),
+        }
+    }
+}
+
+/// Hash commitment of network parameters for a given Network
+pub fn commit_to_custom_network_parameters(params: &NetworkParams) -> sha256::Hash {
+    use hex::{BytesToHexIter, Case};
+    
+    let mut eng = sha256::Hash::engine();
+    eng.input(params.network_id.clone().as_bytes());
+    for ch in BytesToHexIter::new(params.fedpeg_script[..].iter(), Case::Lower).flatten() {
+        eng.input(&[ch.into()]);
+    }
+    for ch in BytesToHexIter::new(params.sign_block_script[..].iter(), Case::Lower).flatten() {
+        eng.input(&[ch.into()]);
+    }
+    sha256::Hash::from_engine(eng)
+}
+
+/// Produce the genesis transaction for a given elements Network
+fn liquid_genesis_tx(network_params: &NetworkParams) -> Transaction {
+    let commit = commit_to_custom_network_parameters(network_params);
+
+    let input = TxIn {
+        previous_output: OutPoint::default(),
+        is_pegin: false,
+        script_sig: script::Builder::new()
+            .push_slice(commit.as_byte_array())
+            .into_script(),
+        sequence: Sequence::default(),
+        asset_issuance: AssetIssuance::default(),
+        witness: TxInWitness::default(),
+    };
+
+    let output = TxOut {
+        asset: confidential::Asset::Explicit(AssetId::default()),
+        value: confidential::Value::Explicit(0),
+        nonce: Nonce::default(),
+        script_pubkey: script::Builder::new().push_opcode(OP_RETURN).into_script(),
+        witness: TxOutWitness::default(),
+    };
+
+    Transaction {
+        version: 1,
+        lock_time: LockTime::ZERO,
+        input: vec![input],
+        output: vec![output],
+    }
+}
+
+/// Create the confidential asset transaction for the genesis block if required by the specified Network
+fn liquid_genesis_asset_tx(network_params: &NetworkParams) -> Option<Transaction> {
+    let commit = commit_to_custom_network_parameters(network_params);
+    let asset_amount = network_params.initial_free_coins;
+    if asset_amount == 0 {
+        return None;
+    }
+    let asset_outpoint = OutPoint::new(Txid::from_byte_array(commit.to_byte_array()), 0);
+    let contract_hash = ContractHash::from_byte_array([0u8; 32]);
+    let asset_entropy = AssetId::generate_asset_entropy(asset_outpoint, contract_hash);
+    let asset_id = AssetId::from_entropy(asset_entropy);
+
+    let asset_issuance = AssetIssuance {
+        asset_blinding_nonce: AssetBlindingNonce::NEW_ISSUANCE,
+        asset_entropy: AssetEntropy::NEW_ISSUANCE,
+        amount: confidential::Value::Explicit(asset_amount),
+        inflation_keys: confidential::Value::Explicit(0),
+    };
+
+    let input = TxIn {
+        previous_output: asset_outpoint,
+        is_pegin: false,
+        script_sig: Script::new(),
+        sequence: Sequence::default(),
+        asset_issuance,
+        witness: TxInWitness::default(),
+    };
+
+    let output = TxOut {
+        asset: confidential::Asset::Explicit(asset_id),
+        value: confidential::Value::Explicit(asset_amount),
+        nonce: Nonce::default(),
+        script_pubkey: script::Builder::new().push_opcode(OP_TRUE).into_script(),
+        witness: TxOutWitness::default(),
+    };
+
+    let ret = Transaction {
+        version: 1,
+        lock_time: LockTime::ZERO,
+        input: vec![input],
+        output: vec![output],
+    };
+    Some(ret)
+}
+
+/// Constructs and returns the Liquid genesis blocks assuming default consensus parameters
+/// Does not return upstream bitcoin network blocks as they are a different format and can be
+/// acquired from the `rust-bitcoin` library
+pub fn genesis_block(params: &NetworkParams) -> Block {
+    let tx = liquid_genesis_tx(params);
+    let mut txdata = vec![tx.clone()];
+
+    let merkle_root: crate::TxMerkleNode =
+        if let Some(asset_tx) = liquid_genesis_asset_tx(params) {
+            // To use `bitcoin::merkle_tree::calculate_root` from bitcoin 0.32, we need a hash
+            // with fairly specific trait bounds, even though it's just used as a byte array.
+            // sha256d::Hash from the rust-bitcoin version of bitcoin_hashes works.
+            use bitcoin::hashes::sha256d::Hash as MerkleHash;
+            use bitcoin::hashes::Hash as _;
+
+            txdata.push(asset_tx.clone());
+            let tx_hashes = [
+                MerkleHash::from_byte_array(tx.txid().to_byte_array()),
+                MerkleHash::from_byte_array(asset_tx.txid().to_byte_array()),
+            ];
+            let root = bitcoin::merkle_tree::calculate_root(tx_hashes.iter().copied())
+                .expect("merkle root");
+            crate::TxMerkleNode::from_byte_array(root.to_byte_array())
+        } else {
+            crate::TxMerkleNode::from_byte_array(tx.txid().to_byte_array())
+        };
+
+    Block {
+        header: BlockHeader {
+            version: 1,
+            prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
+            merkle_root,
+            time: 1_296_688_602,
+            height: 0,
+            ext: BlockExtData::Proof {
+                challenge: params.sign_block_script.clone(),
+                solution: Script::default(),
+            },
+        },
+        txdata,
+    }
+}
+/// The uniquely identifying hash of the target blockchain.
+/// Liquid networks assume default consensus constants, Elements allows for modification of fedpeg and signblock scripts
+/// via configuration argument which will cause these values to differ so these are only for default parameters
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ChainHash([u8; 32]);
+impl_array_newtype!(ChainHash, u8, 32);
+
+impl ChainHash {
+    /// `ChainHash` for Liquid v1 mainnet.
+    pub const LIQUIDV1: Self = Self([
+        3, 96, 32, 138, 136, 150, 146, 55, 44, 141, 104, 176, 132, 166, 46, 253, 246, 14, 161, 163,
+        89, 160, 76, 148, 178, 13, 34, 54, 88, 39, 102, 20,
+    ]);
+    /// `ChainHash` for Liquid testnet.
+    pub const LIQUIDTESTNET: Self = Self([
+        193, 177, 106, 226, 79, 36, 35, 174, 162, 234, 52, 85, 34, 146, 121, 59, 91, 94, 130, 153,
+        154, 30, 237, 129, 213, 106, 238, 82, 142, 218, 113, 167,
+    ]);
+
+    /// Calculates the chainhash for a set of network parameters
+    pub fn for_params(params: &NetworkParams) -> Self {
+        let genesis_block = genesis_block(params);
+        ChainHash(genesis_block.block_hash().to_byte_array())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::genesis::{genesis_block, ChainHash, NetworkParams};
+
+    #[test]
+    fn genesis_block_hash() {
+        let genesis_block = genesis_block(&NetworkParams::liquidv1());
+        assert_eq!(
+            genesis_block.block_hash().to_byte_array(),
+            ChainHash::LIQUIDV1.0
+        );
+
+        let genesis_block =
+            crate::genesis::genesis_block(&NetworkParams::liquidtestnet());
+
+        assert_eq!(
+            genesis_block.block_hash().to_byte_array(),
+            ChainHash::LIQUIDTESTNET.0
+        );
+    }
+}
diff --git a/src/hash_types.rs b/src/hash_types.rs
index 563a1740..cf0b157f 100644
--- a/src/hash_types.rs
+++ b/src/hash_types.rs
@@ -12,52 +12,195 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
-//! File defines types for hashes used throughout the library. These types are needed in order
-//! to avoid mixing data of the same hash format (like SHA256d) but of different meaning
+//! File defines types for hashes used throughout the library.
+//!
+//! These types are needed in order
+//! to avoid mixing data of the same hash format (like `SHA256d`) but of different meaning
 //! (transaction id, block hash etc).
 
-use bitcoin::{
-    hashes::{hash160, sha256, sha256d, Hash},
-    secp256k1::ThirtyTwoByteHash,
-};
+use crate::hashes::{hash160, sha256, sha256d};
+
+// Re-export bitcoin's pubkeyhash types. We already re-export bitcoin's `PublicKey` type.
+pub use bitcoin::{PubkeyHash, WPubkeyHash};
 
 macro_rules! impl_hashencode {
     ($hashtype:ident) => {
         impl $crate::encode::Encodable for $hashtype {
-            fn consensus_encode<S: ::std::io::Write>(&self, s: S) -> Result<usize, $crate::encode::Error> {
-                self.0.consensus_encode(s)
+            fn consensus_encode<W: std::io::Write>(
+                &self,
+                w: W,
+            ) -> Result<usize, crate::encode::Error> {
+                self.as_byte_array().consensus_encode(w)
             }
         }
 
         impl $crate::encode::Decodable for $hashtype {
-            fn consensus_decode<D: ::std::io::Read>(d: D) -> Result<Self, $crate::encode::Error> {
-                use $crate::bitcoin::hashes::Hash;
-                Ok(Self::from_inner(<<$hashtype as $crate::bitcoin::hashes::Hash>::Inner>::consensus_decode(d)?))
+            fn consensus_decode<R: std::io::Read>(r: R) -> Result<Self, $crate::encode::Error> {
+                Ok(Self::from_byte_array(
+                    <<$hashtype as $crate::hashes::Hash>::Bytes>::consensus_decode(r)?,
+                ))
             }
         }
-    }
+    };
 }
 
-hash_newtype!(Txid, sha256d::Hash, 32, doc="A bitcoin transaction hash/transaction ID.");
-hash_newtype!(Wtxid, sha256d::Hash, 32, doc="A bitcoin witness transaction ID.");
-hash_newtype!(BlockHash, sha256d::Hash, 32, doc="A bitcoin block hash.");
-hash_newtype!(SigHash, sha256d::Hash, 32, doc="Hash of the transaction according to the signature algorithm");
+hashes::hash_newtype! {
+    /// An elements transaction ID
+    pub struct Txid(pub(crate) sha256d::Hash);
+    /// An elements witness transaction ID
+    pub struct Wtxid(pub(crate) sha256d::Hash);
+    /// An elements blockhash
+    pub struct BlockHash(pub(crate) sha256d::Hash);
 
-hash_newtype!(PubkeyHash, hash160::Hash, 20, doc="A hash of a public key.");
-hash_newtype!(ScriptHash, hash160::Hash, 20, doc="A hash of Bitcoin Script bytecode.");
-hash_newtype!(WPubkeyHash, hash160::Hash, 20, doc="SegWit version of a public key hash.");
-hash_newtype!(WScriptHash, sha256::Hash, 32, doc="SegWit version of a Bitcoin Script bytecode hash.");
+    /// "Hash of the transaction according to the signature algorithm"
+    pub struct Sighash(pub(crate) sha256d::Hash);
 
-hash_newtype!(TxMerkleNode, sha256d::Hash, 32, doc="A hash of the Merkle tree branch or root for transactions");
+    /// A hash of Bitcoin Script bytecode.
+    pub struct ScriptHash(pub(crate) hash160::Hash);
+    /// SegWit version of a Bitcoin Script bytecode hash.
+    pub struct WScriptHash(pub(crate) sha256::Hash);
+
+    /// A hash of the Merkle tree branch or root for transactions
+    pub struct TxMerkleNode(sha256d::Hash);
+}
+
+
+hashes::impl_hex_for_newtype!(Txid, Wtxid, BlockHash, ScriptHash, WScriptHash, TxMerkleNode);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(Txid, Wtxid, BlockHash, ScriptHash, WScriptHash, TxMerkleNode);
+// We do not implement serde or display/fromstr for 'Sighash'. In general it's dangerous
+// to deserialize sighashes; they must be the output of a cryptographic hash function.
+hashes::impl_debug_only_for_newtype!(Sighash);
 
 impl_hashencode!(Txid);
 impl_hashencode!(Wtxid);
-impl_hashencode!(SigHash);
+impl_hashencode!(Sighash);
 impl_hashencode!(BlockHash);
 impl_hashencode!(TxMerkleNode);
 
-impl ThirtyTwoByteHash for SigHash {
-    fn into_32(self) -> [u8; 32] {
-        self.0.into_inner()
+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 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.
+    pub const COINBASE_PREVOUT: Self = Self::from_byte_array([0; 32]);
+}
+
+impl ScriptHash {
+    /// Computes the `ScriptHash` of a script.
+    pub fn hash_script(s: &crate::Script) -> Self {
+        Self(hash160::Hash::hash(s.as_bytes()))
+    }
+}
+
+impl WScriptHash {
+    /// Computes the `WScriptHash` of a script.
+    pub fn hash_script(s: &crate::Script) -> Self {
+        Self(sha256::Hash::hash(s.as_bytes()))
     }
 }
+
+#[cfg(test)]
+#[cfg(feature = "serde")]
+mod serde_tests {
+    use super::*;
+    use crate::{AssetEntropy, AssetId, ContractHash, DynafedRoot};
+    use crate::dynafed::{ElidedRoot, ParamsRoot};
+
+    /// An arbitrary test vector.
+    ///
+    /// Mainly its goal is to make sure we don't mess up and reverse stuff we don't
+    /// intend to reverse, or vice-versa, so its only requirement is that it not be
+    /// invariant under reversal.
+    const TEST_VECTOR: [u8; 32] = [
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+        0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44,
+        0xff, 0xff, 0xff, 0xff, 0x11, 0x22, 0x33, 0x44,
+    ];
+
+    /// The vector encoded as CBOR
+    const CBOR: [u8; 34] = [
+        0x58, 0x20,
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+        0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44,
+        0xff, 0xff, 0xff, 0xff, 0x11, 0x22, 0x33, 0x44,
+    ];
+    /// The vector encoded as JSON (non-reversed hash)
+    const FORWARD_JSON: &str = "\"0102030405060708090a0b0c0d0e0f100000000011223344ffffffff11223344\"";
+    /// The vector encoded as JSON (reversed hash)
+    const REVERSED_JSON: &str = "\"44332211ffffffff4433221100000000100f0e0d0c0b0a090807060504030201\"";
+
+    /// Constructs a test which attempts to (de-)serialize the 32-byte hash `TEST_VECTOR`,
+    ///
+    /// Checks that serialization works, matches the given target, and can deserialize
+    /// to match the original value.
+    macro_rules! serde_rtt_test32 {
+        ($testname:ident, $ty:ty, $json:expr) => {
+            #[test]
+            fn $testname() {
+                let obj = <$ty>::from_byte_array(TEST_VECTOR);
+                // JSON (human-readable) round-trip
+                let enc_json = serde_json::to_string(&obj).expect("encode json");
+                assert_eq!(
+                    enc_json,
+                    $json,
+                    "encoded JSON did not match target '{}'", $json
+                );
+                let dec_json: $ty = serde_json::from_str(&enc_json).expect("decode json");
+                assert_eq!(
+                    dec_json,
+                    obj,
+                    "decoded JSON did not match object '{}'", obj
+                );
+
+                // CBOR (non-human-readable) round-trip
+                let enc_cbor = serde_cbor::to_vec(&obj).expect("encode cbor");
+                assert_eq!(
+                    enc_cbor,
+                    CBOR,
+                    "encoded CBOR did not match target '{:?}'", CBOR
+                );
+                let dec_cbor: $ty = serde_cbor::from_slice(&enc_cbor).expect("decode cbor");
+                assert_eq!(
+                    dec_cbor,
+                    obj,
+                    "decoded CBOR did not match object '{}'", obj
+                );
+
+                // While we're here, do a string round-trip test
+                let s = obj.to_string();
+                assert_eq!(
+                    s,
+                    $json[1..65],
+                    "encoded string did not match target '{:?}'", $json
+                );
+                let dec_s: $ty = s.parse().expect("parsing string");
+                assert_eq!(
+                    dec_s,
+                    obj,
+                    "decoded string did not match object '{}'", obj
+                );
+            }
+        }
+    }
+
+    serde_rtt_test32!(serde_rtt_txid, Txid, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_wtxid, Wtxid, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_blockhash, BlockHash, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_wscripthash, WScriptHash, FORWARD_JSON);
+    serde_rtt_test32!(serde_rtt_merklenode, TxMerkleNode, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_assetid, AssetId, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_contracthash, ContractHash, REVERSED_JSON);
+
+    serde_rtt_test32!(serde_rtt_entropy, AssetEntropy, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_dynaroot, DynafedRoot, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_elidedroot, ElidedRoot, REVERSED_JSON);
+    serde_rtt_test32!(serde_rtt_paramsroot, ParamsRoot, REVERSED_JSON);
+}
diff --git a/src/internal_macros.rs b/src/internal_macros.rs
index 5c2892db..3a31bb62 100644
--- a/src/internal_macros.rs
+++ b/src/internal_macros.rs
@@ -110,9 +110,8 @@ macro_rules! serde_struct_impl {
                         }
 
                         $(
-                            let $fe = match $fe {
-                                Some(x) => x,
-                                None => return Err(A::Error::missing_field(stringify!($fe))),
+                            let Some($fe) = $fe else {
+                                return Err(A::Error::missing_field(stringify!($fe)));
                             };
                         )*
 
@@ -211,7 +210,7 @@ macro_rules! serde_string_impl {
     };
 }
 
-/// A combination of serde_struct_impl and serde_string_impl where string is
+/// A combination of `serde_struct_impl` and `serde_string_impl` where string is
 /// used for human-readable serialization and struct is used for
 /// non-human-readable serialization.
 macro_rules! serde_struct_human_string_impl {
@@ -348,9 +347,8 @@ macro_rules! serde_struct_human_string_impl {
                             }
 
                             $(
-                                let $fe = match $fe {
-                                    Some(x) => x,
-                                    None => return Err(A::Error::missing_field(stringify!($fe))),
+                                let Some($fe) = $fe else {
+                                    return Err(A::Error::missing_field(stringify!($fe)));
                                 };
                             )*
 
@@ -397,6 +395,94 @@ macro_rules! serde_struct_human_string_impl {
     )
 }
 
+macro_rules! impl_sha256_midstate_wrapper {
+    {
+        #[$($type_attrs:meta)*]
+        pub struct $ty:ident([u8; 32]);
+    } => {
+        $(#[$type_attrs])*
+        #[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+        pub struct $ty([u8; 32]);
+
+        impl $ty {
+            /// Constructs this wrapper struct from raw bytes.
+            pub const fn from_byte_array(inner: [u8; 32]) -> Self {
+                Self(inner)
+            }
+
+            /// The raw bytes within the wrapper type.
+            pub const fn as_byte_array(&self) -> &[u8; 32] {
+                &self.0
+            }
+
+            /// The raw bytes within the wrapper type.
+            pub const fn to_byte_array(self) -> [u8; 32] {
+                self.0
+            }
+
+            /// (Private) convert a sha256 midstate to an object.
+            const fn from_midstate(value: crate::hashes::sha256::Midstate) -> Self {
+                Self(value.to_parts().0)
+            }
+        }
+
+        impl ::std::fmt::Display for $ty {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                ::std::fmt::LowerHex::fmt(&self, f)
+            }
+        }
+
+        impl ::std::fmt::LowerHex for $ty {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                hex::fmt_hex_exact!(f, 32, self.0.iter().rev(), hex::Case::Lower)
+            }
+        }
+
+        impl ::std::fmt::UpperHex for $ty {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                hex::fmt_hex_exact!(f, 32, self.0.iter().rev(), hex::Case::Upper)
+            }
+        }
+
+        impl ::std::fmt::Debug for $ty {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                ::std::fmt::Display::fmt(&self, f)
+            }
+        }
+
+        impl ::core::str::FromStr for $ty {
+            type Err = hex::DecodeFixedLengthBytesError;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                let mut arr = hex::decode_to_array(s)?;
+                arr.reverse();
+                Ok(Self(arr))
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl ::serde::Serialize for $ty {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: serde::Serializer {
+                // "cheat" by just copying sha256d serde serialization
+                crate::hashes::sha256d::Hash::from_byte_array(self.to_byte_array()).serialize(serializer)
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl<'de> ::serde::Deserialize<'de> for $ty {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                where
+                    D: serde::Deserializer<'de> {
+                // "cheat" by just copying sha256d serde serialization
+                let hash = crate::hashes::sha256d::Hash::deserialize(deserializer)?;
+                Ok(Self::from_byte_array(hash.to_byte_array()))
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 macro_rules! hex_deserialize(
     ($e:expr) => ({
@@ -439,9 +525,549 @@ macro_rules! hex_deserialize(
 
 #[cfg(test)]
 macro_rules! hex_script(
-    ($e:expr) => ({
-        let v: Vec<u8> = ::bitcoin::hashes::hex::FromHex::from_hex($e)
-            .expect("hex decoding");
-        crate::Script::from(v)
-    })
+    ($e:expr) => (crate::Script::from_hex_no_prefix($e).expect("hex decoding"))
 );
+
+/// Generates a state machine decoder satisfying the [`crate::encoding::Decoder`] trait.
+///
+/// This macro creates a decoder that processes input bytes through multiple states,
+/// transitioning between states based on decoded data. It automatically generates
+/// both the decoder struct and associated error types.
+///
+/// # Syntax
+///
+/// ```ignore
+/// decoder_state_machine! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(enum InnerEnumName {
+///         Done(TargetType),
+///         Errored,
+///         StateName {
+///             decoder: DecoderType,
+///             field1: FieldType1,
+///             field2: FieldType2,
+///             => transition_function_name(output, ...) -> Result {
+///                 // Transition logic that returns Ok(NextState) or Err(error)
+///             }
+///         },
+///         // ... more states
+///     });
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(enum InnerErrorName {
+///         [macro-inserted decoder variants]
+///         CustomError1(ErrorType1),
+///         CustomError2 { field: ErrorType2 },
+///         // ... custom error variants
+///     });
+/// }
+/// ```
+///
+/// # Generated Code
+///
+/// The macro generates:
+/// - A public decoder struct wrapping a private enum
+/// - A private enum with states, Done, and Errored variants
+/// - Transition functions for each state
+/// - A public error struct wrapping a private error enum
+/// - A private error enum with decoder errors and custom variants
+/// - `Decoder` trait implementation with `push_bytes`, `end`, and `read_limit` methods
+/// - `Decode` impl for the target type
+///
+/// The macro does **not** generate a `fmt::Display` or `std::error::Error` impl
+/// for `ErrorName`, so the user must implement these outside of the macro.
+///
+/// The variants that the macro inserts into `ErrorName` have the same names
+/// as the variants on `InnerEnumName`, and they contain a single value of
+/// type `<DecoderType as Decoder>::Error`.
+///
+/// # State Structure
+///
+/// Each state must have:
+/// - `decoder: SomeDecoderType` - The decoder for this state's data
+/// - Optional additional fields to carry state between transitions
+/// - A transition function that processes the decoder's output
+///
+/// # Transition Functions
+///
+/// Transition functions:
+/// - Take the decoder's output as first parameter
+/// - Take any additional state fields as subsequent parameters
+/// - Return `Result<InnerEnumName, InnerErrorName>`
+/// - Are called automatically when the decoder completes
+///
+/// # Error Handling
+///
+/// The macro automatically:
+/// - Creates error variants for each decoder type
+/// - Maps decoder errors to the appropriate variant
+///
+/// # Example Usage
+///
+/// ```ignore
+/// decoder_state_machine! {
+///     /// Decodes a length-prefixed string
+///     pub struct StringDecoder(enum StringDecoderInner {
+///         Done(String),
+///         Errored,
+///         ReadLength {
+///             decoder: encoding::ArrayDecoder<4>
+///             => transition_read_length(length_bytes, ...) -> Result {
+///                 let length = u32::from_be_bytes(length_bytes) as usize;
+///                 if length > MAX_STRING_LENGTH {
+///                     return Err(StringDecoderErrorInner::StringTooLong { length });
+///                 }
+///                 Ok(StringDecoderInner::ReadData {
+///                     decoder: encoding::VecDecoder::new(length),
+///                     expected_length: length
+///                 })
+///             }
+///         },
+///         ReadData {
+///             decoder: encoding::VecDecoder,
+///             expected_length: usize
+///             => transition_read_data(data, expected_length, ...) -> Result {
+///                 if data.len() != expected_length {
+///                     return Err(StringDecoderErrorInner::LengthMismatch);
+///                 }
+///                 let string = String::from_utf8(data)
+///                     .map_err(StringDecoderErrorInner::InvalidUtf8)?;
+///                 Ok(StringDecoderInner::Done(string))
+///             }
+///         },
+///     });
+///
+///     /// Errors that can occur during string decoding
+///     #[derive(Debug)]
+///     pub struct StringDecoderError(enum StringDecoderErrorInner {
+///         [macro-inserted decoder variants]
+///         StringTooLong { length: usize },
+///         LengthMismatch,
+///         InvalidUtf8(std::string::FromUtf8Error),
+///     });
+/// }
+/// ```
+macro_rules! decoder_state_machine {
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident(enum $inner_ty:ident {
+            Done($target_ty:ty),
+            Errored,
+            $(
+            $variant:ident {
+                decoder: $decoder_ty:ty$(,)?
+                $(, $field:ident: $field_ty:ty)*
+                => $transition_fn:ident($output:ident, ...) -> Result {
+                    $($transition_fn_inner:tt)*
+                }
+            },
+            )*
+        });
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident(enum $inner_error_ty:ident {
+            [macro-inserted decoder variants]
+            $($extra_variants:tt)*
+        });
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        #[allow(clippy::large_enum_variant)]
+        enum $inner_ty {
+            $($variant {
+                decoder: $decoder_ty
+                $(, $field: $field_ty)*
+            },)*
+            Done($target_ty),
+            Errored,
+        }
+
+        impl $inner_ty {
+            $(
+            #[inline]
+            #[allow(clippy::unnecessary_wraps)] // returns a Result even if it never returns Err
+            fn $transition_fn(
+                $output: <$decoder_ty as $crate::encoding::Decoder>::Output
+                $(, $field: $field_ty)*
+            ) -> Result<Self, $inner_error_ty> {
+                $($transition_fn_inner)*
+            }
+            )*
+        }
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_error_ty);
+
+        $(#[$($error_struct_attr)*])*
+        enum $inner_error_ty {
+            $(
+            $variant(<$decoder_ty as $crate::encoding::Decoder>::Error),
+            )*
+            $($extra_variants)*
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                use $inner_ty as Inner;
+                loop {
+                    match core::mem::replace(&mut self.0, Inner::Errored) {
+                        $(
+                        Inner::$variant { mut decoder $(, $field)* } => {
+                            if decoder
+                                .push_bytes(bytes)
+                                .map_err($inner_error_ty::$variant)
+                                .map_err($error_ty)?
+                                .needs_more()
+                            {
+                                self.0 = Inner::$variant { decoder $(, $field)* };
+                                return Ok($crate::encoding::DecoderStatus::NeedsMore);
+                            }
+
+                            let output = decoder.end()
+                                .map_err($inner_error_ty::$variant)
+                                .map_err($error_ty)?;
+                            self.0 = $inner_ty::$transition_fn(output $(, $field)*)
+                                .map_err($error_ty)?;
+                        }
+                        )*
+                        Inner::Done(out) => {
+                            self.0 = Inner::Done(out);
+                            return Ok($crate::encoding::DecoderStatus::Ready);
+                        }
+                        Inner::Errored => panic!("called push_bytes() on an errored decoder"),
+
+                    }
+                }
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                use $inner_ty as Inner;
+                match self.0 {
+                    $(
+                    Inner::$variant { decoder, .. } => {
+                        decoder.end()
+                            .map_err($inner_error_ty::$variant)
+                            .map_err($error_ty)?;
+                        // This unreachable! can be hit by badly behaved decoders where push_bytes()
+                        // returns DecoderStatus::NeedMore, but end() returns Ok. In general, end()
+                        // should return Ok only if push_bytes has returned DecoderStatus::Ready.
+                        unreachable!(
+                            "end() succeeded on decoder for {} state, but we did not leave that state",
+                            stringify!($variant),
+                        )
+                    }
+                    )*
+                    Inner::Done(out) => Ok(out),
+                    Inner::Errored => panic!("called end() on an errored decoder"),
+                }
+            }
+
+            fn read_limit(&self) -> usize {
+                use $inner_ty as Inner;
+                match self.0 {
+                    $(
+                    Inner::$variant { ref decoder, .. } => decoder.read_limit(),
+                    )*
+                    Inner::Done(_) | Inner::Errored => 0,
+                }
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty {
+            type Decoder = $outer_ty;
+        }
+    };
+}
+
+/// Generates a simple decoder wrapper that converts output from an inner decoder.
+///
+/// This macro creates a decoder that wraps an existing decoder and applies a conversion
+/// function to transform the inner decoder's output into the target type. It's simpler
+/// than `decoder_state_machine!` as it only wraps a single decoder without state transitions.
+///
+/// # Syntax
+///
+/// There are two invocation patterns:
+///
+/// ## Direct Error Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(InnerDecoderType);
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(InnerErrorName);
+///     const ERROR_DISPLAY = "output of the Display::fmt function";
+///
+///     impl Decode for TargetType {
+///         fn convert_inner(output_var) -> Result<_, InnerErrorName> {
+///             // Conversion logic -- returns `InnerErrorName` for errors!
+///         }
+///     }
+/// }
+/// ```
+///
+/// In this case `InnerErrorName` must be an already-existing error type.
+///
+/// ## Error Enum Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(InnerDecoderType);
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(enum InnerErrorName {
+///         // The first variant must be called Decode and hold the inner decoder type.
+///         Decode(InnerDecoderErrorType),
+///         // All other variants are free-form.
+///         CustomError1(ErrorType1),
+///         CustomError2 { field: ErrorType2 },
+///         // ... custom error variants
+///     });
+///
+///     impl Decode for TargetType {
+///         fn convert_inner(output_var) -> Result<_, ErrorName> {
+///             // Conversion logic -- returns `ErrorName` for errors!
+///         }
+///     }
+/// }
+/// ```
+///
+/// In this case `InnerErrorName` will be generated as a private enum by the macro.
+///
+/// # Generated Code
+///
+/// The macro generates:
+/// - A public decoder struct wrapping the inner decoder
+/// - A public error struct wrapping a private error enum
+/// - A private error enum with `Decode` variant and custom variants
+/// - `Decoder` trait implementation with `push_bytes`, `end`, and `read_limit` methods
+/// - `Decode` trait implementation for the target type
+///
+/// **When using the enum pattern, the macro does not generate a `fmt::Display` or
+/// `std::error::Error` impl for `ErrorName`. The user must implement these outside
+/// of the macro.** When using the non-enum pattern, both `Display` and `Error` are
+/// generated by the macro.
+///
+/// # Parameters
+///
+/// - `DecoderName` - The wrapper decoder struct name
+/// - `InnerDecoderType` - The existing decoder type to wrap
+/// - `ErrorName` - The error struct name
+/// - `InnerErrorName` - The private error enum name
+/// - `InnerDecoderErrorType` - The error type from the inner decoder
+/// - `TargetType` - The final output type after conversion
+/// - `convert_inner` - Function that converts inner output to target type
+///
+/// # Conversion Function
+///
+/// The conversion function:
+/// - Takes the inner decoder's output as its parameter
+/// - Returns `Result<TargetType, ErrorName>` for enum pattern, `Result<TargetType, InnerErrorName>`
+///   for direct-wrapping pattern.
+/// - Is called automatically when the inner decoder completes
+/// - Can return custom errors defined in the error enum (enum pattern only)
+///
+/// # Pattern Selection
+///
+/// - Use **direct error wrapping** when conversion cannot fail or only needs to propagate the inner decoder's errors
+/// - Use **error enum wrapping** when conversion can fail with custom error types
+///
+/// # Error Handling
+///
+/// The macro automatically:
+/// - Creates a `Decode` variant containing the inner decoder's error
+/// - Maps inner decoder errors to the `Decode` variant
+/// - Allows custom error variants for conversion failures
+///
+/// # Example Usage
+///
+/// ## Direct Error Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Decoder for the [`TxOut`] type.
+///     #[derive(Default)]
+///     pub struct TxOutDecoder(Decoder4< crate::confidential::AssetDecoder,
+///         crate::confidential::ValueDecoder,
+///         crate::confidential::NonceDecoder,
+///         crate::script::ScriptDecoder,
+///     >);
+///
+///     /// Decoder error for the [`TxOut`] type.
+///     #[derive(Clone, PartialEq, Eq, Debug)]
+///     pub struct TxOutDecoderError(Decoder4Error<
+///         crate::confidential::AssetDecoderError,
+///         crate::confidential::ValueDecoderError,
+///         crate::confidential::NonceDecoderError,
+///         crate::script::ScriptDecoderError,
+///     >);
+///     const ERROR_DISPLAY = "error decoding transaction output witness";
+///
+///     impl Decode for TxOut {
+///         fn convert_inner(output) -> Result<_, TxOutDecoderErrorInner> {
+///             let (asset, value, nonce, script_pubkey) = output;
+///             Ok(TxOut { asset, value, nonce, script_pubkey, witness: TxOutWitness::empty() })
+///         }
+///     }
+/// }
+/// ```
+///
+/// ## Error Enum Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Decoder for range proofs
+///     #[derive(Default)]
+///     pub struct Decoder(encoding::ByteVecDecoder);
+///
+///     /// Decoder error for range proofs
+///     #[derive(Clone, PartialEq, Eq, Debug)]
+///     pub struct DecoderError(enum DecoderErrorInner {
+///         Decode(encoding::ByteVecDecoderError),
+///         RangeProof(secp256k1_zkp::Error),
+///     });
+///
+///     impl Decode for RangeProof {
+///         fn convert_inner(v) -> Result<_, DecoderError> {
+///             RangeProof::from_slice(&v).map_err(DecoderError::RangeProof)
+///         }
+///     }
+/// }
+/// ```
+macro_rules! decoder_newtype {
+    // With directly wrapped inner error
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident($inner_ty:ty);
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident($inner_ty_error:ty);
+
+        const ERROR_DISPLAY = $error_display:expr;
+
+        impl Decode for $target_ty:ty {
+            fn convert_inner($output:ident) -> Result<_, $error_inner1:ty> {
+                $($output_fn_inner:tt)*
+            }
+        }
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_ty_error);
+
+        impl core::fmt::Display for $error_ty {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str($error_display)
+            }
+        }
+
+        impl std::error::Error for $error_ty {
+            fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+                Some(&self.0)
+            }
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                self.0
+                    .push_bytes(bytes)
+                    .map_err($error_ty)
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                let $output = self.0
+                    .end()
+                    .map_err($error_ty)?;
+                let converted = {
+                    $($output_fn_inner)*
+                };
+                converted.map_err($error_ty)
+            }
+
+            fn read_limit(&self) -> usize {
+                self.0.read_limit()
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty{
+            type Decoder = $outer_ty;
+        }
+    };
+    // With inner error enum
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident($inner_ty:ty);
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident(enum $inner_error_ty:ident {
+            Decode($inner_ty_error:ty),
+            $($extra_variants:tt)*
+        });
+
+        impl Decode for $target_ty:ty {
+            fn convert_inner($output:ident) -> Result<_, $error_inner1:ty> {
+                $($output_fn_inner:tt)*
+            }
+        }
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_error_ty);
+
+        $(#[$($error_struct_attr)*])*
+        enum $inner_error_ty {
+            Decode($inner_ty_error),
+            $($extra_variants)*
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                self.0
+                    .push_bytes(bytes)
+                    .map_err($inner_error_ty::Decode)
+                    .map_err($error_ty)
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                let $output = self.0
+                    .end()
+                    .map_err($inner_error_ty::Decode)
+                    .map_err($error_ty)?;
+                let converted = {
+                    $($output_fn_inner)*
+                };
+                converted.map_err($error_ty)
+            }
+
+            fn read_limit(&self) -> usize {
+                self.0.read_limit()
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty{
+            type Decoder = $outer_ty;
+        }
+    };
+}
diff --git a/src/issuance.rs b/src/issuance.rs
index 9329b282..5b043fe7 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -14,15 +14,17 @@
 
 //! Asset Issuance
 
+use core::fmt;
 use std::io;
-use std::str::FromStr;
-
-use bitcoin::hashes::{self, hex, sha256, sha256d, Hash};
 
+use crate::confidential::AssetBlindingFactor;
 use crate::encode::{self, Encodable, Decodable};
+use crate::hashes::{hash_newtype, sha256, sha256d};
 use crate::fast_merkle_root::fast_merkle_root;
 use secp256k1_zkp::Tag;
+use crate::genesis::{commit_to_custom_network_parameters, NetworkParams};
 use crate::transaction::OutPoint;
+use crate::Txid;
 
 /// The zero hash.
 const ZERO32: [u8; 32] = [
@@ -37,7 +39,176 @@ const TWO32: [u8; 32] = [
     2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 ];
 
-hash_newtype!(ContractHash, sha256::Hash, 32, doc="The hash of an asset contract.", true);
+hash_newtype!(
+    /// The hash of an asset contract.
+    #[hash_newtype(backward)]
+    pub struct ContractHash(sha256::Hash);
+);
+hashes::impl_hex_for_newtype!(ContractHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(ContractHash);
+
+impl_sha256_midstate_wrapper! {
+    /// A hash of some data used as "asset entropy" to seed the ID of a new asset.
+    pub struct AssetEntropy([u8; 32]);
+}
+
+impl AssetEntropy {
+    /// The all-zeroes "entropy" used for new issuances (vs reissuances).
+    pub const NEW_ISSUANCE: Self = Self([0; 32]);
+
+    /// Re-interpret the asset entropy as a contract hash.
+    pub fn into_contract_hash(self) -> ContractHash {
+        ContractHash::from_byte_array(self.0)
+    }
+}
+
+impl Encodable for AssetEntropy {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+       self.0.consensus_encode(e) 
+    }
+}
+
+impl Decodable for AssetEntropy {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        <[u8; 32]>::consensus_decode(d).map(Self)
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`AssetEntropyEncoder`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetEntropyEncoder<'e>(encoding::ArrayRefEncoder<'e, 32>);
+}
+
+impl encoding::Encode for AssetEntropy {
+    type Encoder<'e> = AssetEntropyEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetEntropyEncoder::new(encoding::ArrayRefEncoder::without_length_prefix(&self.0))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`AssetEntropy`] type.
+    #[derive(Default)]
+    pub struct AssetEntropyDecoder(encoding::ArrayDecoder<32>);
+
+    /// Decoder error for the [`AssetEntropy`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetEntropyDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding asset entropy";
+
+    impl Decode for AssetEntropy {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(AssetEntropy::from_byte_array(bytes))
+        }
+    }
+}
+
+/// The blinding factor used to derive an asset commitment from an asset.
+///
+/// This type represents either [`Self::NEW_ISSUANCE`], indicating that an asset
+/// issuance is of a new asset, or for a reissuance, the [`AssetBlindingFactor`]
+/// used to blind the reissuance token (which must be blinded in order to be
+/// spent, due to a quirk in the Elements consensus code.)
+///
+/// Conceptually this can be thought of as an `Option<AssetBlindingFactor>`, except
+/// that there are no invalid values; [`AssetBlindingNonce::from_byte_array`] will
+/// always succeed. However, if an out-of-range value is used, the transaction will
+/// fail validation no matter what reissuance token is used.
+///
+/// Also, **unlike [`AssetBlindingFactor`], this type represents public data**. You
+/// can convert a blinding factor into a "blinding nonce", and while this conversion
+/// is technically a no-op, conceptually it represents choosing to make the blinding
+/// factor public.
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord, Default)]
+pub struct AssetBlindingNonce([u8; 32]);
+
+impl AssetBlindingNonce {
+    /// A null blinding nonce, representing a new issuance (vs a reissuance).
+    pub const NEW_ISSUANCE: Self = Self([0; 32]);
+
+    /// Constructs this wrapper struct from raw bytes.
+    pub const fn from_byte_array(inner: [u8; 32]) -> Self {
+        Self(inner)
+    }
+
+    /// The raw bytes within the wrapper type.
+    pub const fn as_byte_array(&self) -> &[u8; 32] {
+        &self.0
+    }
+
+    /// The raw bytes within the wrapper type.
+    pub const fn to_byte_array(self) -> [u8; 32] {
+        self.0
+    }
+
+    /// Whether this is the null "new issuance" blinding nonce.
+    pub fn is_null(&self) -> bool {
+        // This is surprisingly annoying to make into a constfn, so we don't
+        // bother for now.
+        *self == Self::NEW_ISSUANCE
+    }
+
+    /// Reinterpret an asset blinding factor as a [`AssetBlindingNonce`].
+    ///
+    /// This is something of a dangerous function, since in general blinding factors should
+    /// be considered secret data, while blinding nonces are public (they are encoded on
+    /// the blockchain). So callers of this function should be sure that this is a blinding
+    /// factor that they intend to reveal.)
+    pub fn from_blinding_factor(bf: AssetBlindingFactor) -> Self {
+        Self(*bf.into_inner().as_ref())
+    }
+}
+
+impl Encodable for AssetBlindingNonce {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+       self.0.consensus_encode(e) 
+    }
+}
+
+impl Decodable for AssetBlindingNonce {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        <[u8; 32]>::consensus_decode(d).map(Self)
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`AssetBlindingNonce`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetBlindingNonceEncoder<'e>(encoding::ArrayRefEncoder<'e, 32>);
+}
+
+impl encoding::Encode for AssetBlindingNonce {
+    type Encoder<'e> = AssetBlindingNonceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetBlindingNonceEncoder::new(encoding::ArrayRefEncoder::without_length_prefix(&self.0))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`AssetBlindingNonce`] type.
+    #[derive(Default)]
+    pub struct AssetBlindingNonceDecoder(encoding::ArrayDecoder<32>);
+
+    /// Decoder error for the [`AssetBlindingNonce`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetBlindingNonceDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding asset blinding nonce";
+
+    impl Decode for AssetBlindingNonce {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(AssetBlindingNonce::from_byte_array(bytes))
+        }
+    }
+}
+
+impl_sha256_midstate_wrapper! {
+    /// An issued asset ID.
+    pub struct AssetId([u8; 32]);
+}
 
 impl ContractHash {
     /// Calculate the contract hash of a JSON contract object.
@@ -47,51 +218,42 @@ impl ContractHash {
     /// the hash.
     #[cfg(feature = "json-contract")]
     pub fn from_json_contract(json: &str) -> Result<ContractHash, ::serde_json::Error> {
+        use crate::hashes::HashEngine as _;
+        
         // Parsing the JSON into a BTreeMap will recursively order object keys
         // lexicographically. This order is respected when we later serialize
         // it again.
         let ordered: ::std::collections::BTreeMap<String, ::serde_json::Value> =
             ::serde_json::from_str(json)?;
 
-        let mut engine = ContractHash::engine();
+        let mut engine = sha256::Hash::engine();
         ::serde_json::to_writer(&mut engine, &ordered).expect("engines don't error");
-        Ok(ContractHash::from_engine(engine))
+        Ok(ContractHash(engine.finalize()))
     }
 }
 
-/// An issued asset ID.
-#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
-pub struct AssetId(sha256::Midstate);
-
 impl AssetId {
     /// The asset ID for L-BTC, Bitcoin on the Liquid network.
-    pub const LIQUID_BTC: AssetId = AssetId(sha256::Midstate([
+    pub const LIQUID_BTC: AssetId = AssetId([
         0x6d, 0x52, 0x1c, 0x38, 0xec, 0x1e, 0xa1, 0x57,
         0x34, 0xae, 0x22, 0xb7, 0xc4, 0x60, 0x64, 0x41,
         0x28, 0x29, 0xc0, 0xd0, 0x57, 0x9f, 0x0a, 0x71,
         0x3d, 0x1c, 0x04, 0xed, 0xe9, 0x79, 0x02, 0x6f,
-    ]));
+    ]);
 
-    /// Create an [AssetId] from its inner type.
-    pub fn from_inner(midstate: sha256::Midstate) -> AssetId {
-        AssetId(midstate)
-    }
-
-    /// Convert the [AssetId] into its inner type.
-    pub fn into_inner(self) -> sha256::Midstate {
-        self.0
-    }
-
-    /// Copies a byte slice into an AssetId object
-    pub fn from_slice(sl: &[u8]) -> Result<AssetId, hashes::Error> {
-        sha256::Midstate::from_slice(sl).map(AssetId)
-    }
+    /// The asset ID for L-BTC, Bitcoin on the Liquidtestnet network.
+    pub const LIQUIDTESTNET_BTC: AssetId = AssetId([
+        0x49, 0x9a, 0x81, 0x85, 0x45, 0xf6, 0xba, 0xe3,
+        0x9f, 0xc0, 0x3b, 0x63, 0x7f, 0x2a, 0x4e, 0x1e,
+        0x64, 0xe5, 0x90, 0xca, 0xc1, 0xbc, 0x3a, 0x6f,
+        0x6d, 0x71, 0xaa, 0x44, 0x43, 0x65, 0x4c, 0x14,
+    ]);
 
     /// Generate the asset entropy from the issuance prevout and the contract hash.
     pub fn generate_asset_entropy(
         prevout: OutPoint,
         contract_hash: ContractHash,
-    ) -> sha256::Midstate {
+    ) -> AssetEntropy {
         // E : entropy
         // I : prevout
         // C : contract
@@ -101,15 +263,15 @@ impl AssetId {
             prevout.consensus_encode(&mut enc).unwrap();
             sha256d::Hash::from_engine(enc)
         };
-        fast_merkle_root(&[prevout_hash.into_inner(), contract_hash.into_inner()])
+        AssetEntropy::from_midstate(fast_merkle_root(&[prevout_hash.to_byte_array(), contract_hash.to_byte_array()]))
     }
 
     /// Calculate the asset ID from the asset entropy.
-    pub fn from_entropy(entropy: sha256::Midstate) -> AssetId {
+    pub fn from_entropy(entropy: AssetEntropy) -> AssetId {
         // H_a : asset tag
         // E   : entropy
         // H_a = H( E || 0 )
-        AssetId(fast_merkle_root(&[entropy.into_inner(), ZERO32]))
+        AssetId::from_midstate(fast_merkle_root(&[entropy.to_byte_array(), ZERO32]))
     }
 
     /// Computes the asset ID when issuing asset from issuing input and contract hash
@@ -125,7 +287,7 @@ impl AssetId {
     }
 
     /// Calculate the reissuance token asset ID from the asset entropy.
-    pub fn reissuance_token_from_entropy(entropy: sha256::Midstate, confidential: bool) -> AssetId {
+    pub fn reissuance_token_from_entropy(entropy: AssetEntropy, confidential: bool) -> AssetId {
         // H_a : asset reissuance tag
         // E   : entropy
         // if not fConfidential:
@@ -136,46 +298,36 @@ impl AssetId {
             false => ONE32,
             true => TWO32,
         };
-        AssetId(fast_merkle_root(&[entropy.into_inner(), second]))
+        AssetId::from_midstate(fast_merkle_root(&[entropy.to_byte_array(), second]))
     }
 
     /// Convert an asset into [Tag]
     pub fn into_tag(self) -> Tag {
-        self.0.into_inner().into()
+        self.0.into()
     }
-}
 
-impl hex::FromHex for AssetId {
-    fn from_byte_iter<I>(iter: I) -> Result<Self, hex::Error>
-    where
-        I: Iterator<Item = Result<u8, hex::Error>> + ExactSizeIterator + DoubleEndedIterator,
-    {
-        sha256::Midstate::from_byte_iter(iter).map(AssetId)
-    }
-}
-
-impl ::std::fmt::Display for AssetId {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        ::std::fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl ::std::fmt::Debug for AssetId {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        ::std::fmt::Display::fmt(&self, f)
-    }
-}
-
-impl ::std::fmt::LowerHex for AssetId {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        ::std::fmt::LowerHex::fmt(&self.0, f)
+    /// Pegged asset id for given network parameters
+    pub fn pegged_asset_id_for_network_params(params: &NetworkParams) -> AssetId {
+        match params.network_id.as_str() {
+            "liquidv1" => Self::LIQUID_BTC,
+            "liquidtestnet" => Self::LIQUIDTESTNET_BTC,
+            _ => {
+                // Else calculate the asset_id
+                Self::pegged_asset_id_for_params_and_parent_chain_hash(
+                    params,
+                    bitcoin::Network::Regtest.chain_hash(),
+                )
+            }
+        }
     }
-}
 
-impl FromStr for AssetId {
-    type Err = hex::Error;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        hex::FromHex::from_hex(s)
+    /// Calculate the `AssetId` for the pegged asset for a given set of network parameters assuming
+    /// a Regtest parent network
+    fn pegged_asset_id_for_params_and_parent_chain_hash(params: &NetworkParams, parent_chainhash: bitcoin::blockdata::constants::ChainHash) -> AssetId {
+        let commit = commit_to_custom_network_parameters(params);
+        let asset_outpoint = OutPoint::new(Txid::from_byte_array(commit.to_byte_array()), 0);
+        let asset_entropy = AssetId::generate_asset_entropy(asset_outpoint, ContractHash::from_byte_array(*parent_chainhash.as_ref()));
+        AssetId::from_entropy(asset_entropy)
     }
 }
 
@@ -187,82 +339,37 @@ impl Encodable for AssetId {
 
 impl Decodable for AssetId {
     fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        Ok(Self::from_inner(sha256::Midstate::consensus_decode(d)?))
+        Decodable::consensus_decode(d).map(Self)
     }
 }
 
-#[cfg(feature = "serde")]
-impl ::serde::Serialize for AssetId {
-    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use bitcoin::hashes::hex::ToHex;
-        if s.is_human_readable() {
-            s.serialize_str(&self.to_hex())
-        } else {
-            s.serialize_bytes(&self.0[..])
-        }
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`AssetId`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetIdEncoder<'e>(encoding::ArrayRefEncoder<'e, 32>);
+}
+
+impl encoding::Encode for AssetId {
+    type Encoder<'e> = AssetIdEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetIdEncoder::new(encoding::ArrayRefEncoder::without_length_prefix(&self.0))
     }
 }
 
-#[cfg(feature = "serde")]
-impl<'de> ::serde::Deserialize<'de> for AssetId {
-    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<AssetId, D::Error> {
-        use bitcoin::hashes::hex::FromHex;
-
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = AssetId;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
-                        AssetId::from_hex(hex).map_err(E::custom)
-                    } else {
-                        return 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,
-                {
-                    AssetId::from_hex(v).map_err(E::custom)
-                }
-            }
+decoder_newtype! {
+    /// Decoder for the [`AssetId`] type.
+    #[derive(Default)]
+    pub struct AssetIdDecoder(encoding::ArrayDecoder<32>);
 
-            d.deserialize_str(HexVisitor)
-        } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = AssetId;
-
-                fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                    formatter.write_str("a bytestring")
-                }
-
-                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    if v.len() != 32 {
-                        Err(E::invalid_length(v.len(), &stringify!($len)))
-                    } else {
-                        let mut ret = [0; 32];
-                        ret.copy_from_slice(v);
-                        Ok(AssetId(sha256::Midstate::from_inner(ret)))
-                    }
-                }
-            }
+    /// Decoder error for the [`AssetId`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetIdDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding asset ID";
 
-            d.deserialize_bytes(BytesVisitor)
+    impl Decode for AssetId {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(AssetId::from_byte_array(bytes))
         }
     }
 }
@@ -271,9 +378,7 @@ impl<'de> ::serde::Deserialize<'de> for AssetId {
 mod test {
     use super::*;
     use std::str::FromStr;
-
-    use bitcoin::hashes::hex::FromHex;
-    use bitcoin::hashes::sha256;
+    use bitcoin::constants::ChainHash;
 
     #[test]
     fn example_elements_core() {
@@ -283,13 +388,13 @@ mod test {
         let asset_id_hex = "dcd60818d863b5c026c40b2bc3ba6fdaf5018bcc8606c18adf7db4da0bcd8533";
         let token_id_hex = "c1adb114f4f87d33bf9ce90dd4f9ca523dd414d6cd010a7917903e2009689530";
 
-        let contract_hash = ContractHash::from_inner(ZERO32);
+        let contract_hash = ContractHash::from_byte_array(ZERO32);
         let prevout = OutPoint::from_str(prevout_str).unwrap();
-        let entropy = sha256::Midstate::from_hex(entropy_hex).unwrap();
+        let entropy = AssetEntropy::from_str(entropy_hex).unwrap();
         assert_eq!(AssetId::generate_asset_entropy(prevout, contract_hash), entropy);
-        let asset_id = AssetId::from_hex(asset_id_hex).unwrap();
+        let asset_id = AssetId::from_str(asset_id_hex).unwrap();
         assert_eq!(AssetId::from_entropy(entropy), asset_id);
-        let token_id = AssetId::from_hex(token_id_hex).unwrap();
+        let token_id = AssetId::from_str(token_id_hex).unwrap();
         assert_eq!(AssetId::reissuance_token_from_entropy(entropy, false), token_id);
 
         // example test data from Elements Core 0.21 with prevout vout = 1
@@ -298,13 +403,13 @@ mod test {
         let asset_id_hex = "2ec6c1a06e895b06fffb8dc36084255f890467fb906565b0c048d4c807b4a129";
         let token_id_hex = "d09d205ff7c626ca98c91fed24787ff747fec62194ed1b7e6ef6cc775a1a1fdc";
 
-        let contract_hash = ContractHash::from_inner(ZERO32);
+        let contract_hash = ContractHash::from_byte_array(ZERO32);
         let prevout = OutPoint::from_str(prevout_str).unwrap();
-        let entropy = sha256::Midstate::from_hex(entropy_hex).unwrap();
+        let entropy = AssetEntropy::from_str(entropy_hex).unwrap();
         assert_eq!(AssetId::generate_asset_entropy(prevout, contract_hash), entropy);
-        let asset_id = AssetId::from_hex(asset_id_hex).unwrap();
+        let asset_id = AssetId::from_str(asset_id_hex).unwrap();
         assert_eq!(AssetId::from_entropy(entropy), asset_id);
-        let token_id = AssetId::from_hex(token_id_hex).unwrap();
+        let token_id = AssetId::from_str(token_id_hex).unwrap();
         assert_eq!(AssetId::reissuance_token_from_entropy(entropy, true), token_id);
 
 
@@ -315,13 +420,13 @@ mod test {
         let asset_id_hex = "8eebf6109bca0331fe559f0cbd1ef846a2bbb6812f3ae3d8b0b610170cc21a4e"; // parsed reverse
         let token_id_hex = "eb02cbc591c9ede071625c129f0a1fab386202cb27a894a45be0d564e961d6bc"; // parsed reverse
 
-        let contract_hash = ContractHash::from_hex(contract_hash_hex).unwrap();
+        let contract_hash = ContractHash::from_str(contract_hash_hex).unwrap();
         let prevout = OutPoint::from_str(prevout_str).unwrap();
-        let entropy = sha256::Midstate::from_hex(entropy_hex).unwrap();
+        let entropy = AssetEntropy::from_str(entropy_hex).unwrap();
         assert_eq!(AssetId::generate_asset_entropy(prevout, contract_hash), entropy);
-        let asset_id = AssetId::from_hex(asset_id_hex).unwrap();
+        let asset_id = AssetId::from_str(asset_id_hex).unwrap();
         assert_eq!(AssetId::from_entropy(entropy), asset_id);
-        let token_id = AssetId::from_hex(token_id_hex).unwrap();
+        let token_id = AssetId::from_str(token_id_hex).unwrap();
         assert_eq!(AssetId::reissuance_token_from_entropy(entropy, false), token_id);
 
         // example test data from Elements Core 0.21
@@ -331,44 +436,44 @@ mod test {
         let asset_id_hex = "bdab916e8cda17781bcdb84505452e44d0ab2f080e9e5dd7765ffd5ce0c07cd9";
         let token_id_hex = "f144868169dfc7afc024c4d8f55607ac8dfe925e67688650a9cdc54c3cfa5b1c";
 
-        let contract_hash = ContractHash::from_inner(ZERO32);
+        let contract_hash = ContractHash::from_byte_array(ZERO32);
         let prevout = OutPoint::from_str(prevout_str).unwrap();
-        let entropy = sha256::Midstate::from_hex(entropy_hex).unwrap();
+        let entropy = AssetEntropy::from_str(entropy_hex).unwrap();
         assert_eq!(AssetId::generate_asset_entropy(prevout, contract_hash), entropy);
-        let asset_id = AssetId::from_hex(asset_id_hex).unwrap();
+        let asset_id = AssetId::from_str(asset_id_hex).unwrap();
         assert_eq!(AssetId::from_entropy(entropy), asset_id);
-        let token_id = AssetId::from_hex(token_id_hex).unwrap();
+        let token_id = AssetId::from_str(token_id_hex).unwrap();
         assert_eq!(AssetId::reissuance_token_from_entropy(entropy, true), token_id);
     }
 
     #[cfg(feature = "json-contract")]
     #[test]
     fn test_json_contract() {
-        let tether = ContractHash::from_hex("3c7f0a53c2ff5b99590620d7f6604a7a3a7bfbaaa6aa61f7bfc7833ca03cde82").unwrap();
+        let tether = ContractHash::from_str("3c7f0a53c2ff5b99590620d7f6604a7a3a7bfbaaa6aa61f7bfc7833ca03cde82").unwrap();
 
         let correct = r#"{"entity":{"domain":"tether.to"},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","name":"Tether USD","precision":8,"ticker":"USDt","version":0}"#;
-        let expected = ContractHash::hash(correct.as_bytes());
-        assert_eq!(tether, expected);
-        assert_eq!(expected, ContractHash::from_json_contract(&correct).unwrap());
+        let expected = sha256::Hash::hash(correct.as_bytes()).to_byte_array();
+        assert_eq!(tether.to_byte_array(), expected);
+        assert_eq!(expected, ContractHash::from_json_contract(correct).unwrap().to_byte_array());
 
         let invalid_json = r#"{"entity":{"domain":"tether.to"},"issuer_pubkey:"#;
-        assert!(ContractHash::from_json_contract(&invalid_json).is_err());
+        assert!(ContractHash::from_json_contract(invalid_json).is_err());
 
         let unordered = r#"{"precision":8,"ticker":"USDt","entity":{"domain":"tether.to"},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","name":"Tether USD","version":0}"#;
-        assert_eq!(expected, ContractHash::from_json_contract(&unordered).unwrap());
+        assert_eq!(expected, ContractHash::from_json_contract(unordered).unwrap().to_byte_array());
 
         let unordered = r#"{"precision":8,"name":"Tether USD","ticker":"USDt","entity":{"domain":"tether.to"},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","version":0}"#;
-        assert_eq!(expected, ContractHash::from_json_contract(&unordered).unwrap());
+        assert_eq!(expected, ContractHash::from_json_contract(unordered).unwrap().to_byte_array());
 
         let spaces = r#"{"precision":8, "name" : "Tether USD", "ticker":"USDt",  "entity":{"domain":"tether.to" }, "issuer_pubkey" :"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","version":0} "#;
-        assert_eq!(expected, ContractHash::from_json_contract(&spaces).unwrap());
+        assert_eq!(expected, ContractHash::from_json_contract(spaces).unwrap().to_byte_array());
 
         let nested_correct = r#"{"entity":{"author":"Tether Inc","copyright":2020,"domain":"tether.to","hq":"Mars"},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","name":"Tether USD","precision":8,"ticker":"USDt","version":0}"#;
-        let nested_expected = ContractHash::hash(nested_correct.as_bytes());
-        assert_eq!(nested_expected, ContractHash::from_json_contract(&nested_correct).unwrap());
+        let nested_expected = sha256::Hash::hash(nested_correct.as_bytes()).to_byte_array();
+        assert_eq!(nested_expected, ContractHash::from_json_contract(nested_correct).unwrap().to_byte_array());
 
         let nested_unordered = r#"{"ticker":"USDt","entity":{"domain":"tether.to","hq":"Mars","author":"Tether Inc","copyright":2020},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","name":"Tether USD","precision":8,"version":0}"#;
-        assert_eq!(nested_expected, ContractHash::from_json_contract(&nested_unordered).unwrap());
+        assert_eq!(nested_expected, ContractHash::from_json_contract(nested_unordered).unwrap().to_byte_array());
     }
 
     #[test]
@@ -378,4 +483,52 @@ mod test {
             "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d",
         );
     }
+
+    #[test]
+    fn liquid_asset_ids() {
+        // Testing the two most common Regtest networks using in Liquid and CLN codebases
+        let network_params = NetworkParams::custom_network("elementsregtest".to_string(), None, None, None);
+        let asset_id = AssetId::pegged_asset_id_for_params_and_parent_chain_hash(
+            &network_params,
+            bitcoin::Network::Regtest.chain_hash(),
+        );
+
+        let elementsregtest_asset_id = AssetId([
+            0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4,
+            0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2,
+            0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2,
+        ]);
+
+        assert_eq!(asset_id, elementsregtest_asset_id);
+
+        let network_params = NetworkParams::custom_network("liquid-regtest".to_string(), None, None, None);
+        let asset_id = AssetId::pegged_asset_id_for_params_and_parent_chain_hash(
+            &network_params,
+            bitcoin::Network::Regtest.chain_hash(),
+        );
+
+        let liquid_regtest_assetid = AssetId([
+            0x5c, 0xe7, 0xb9, 0x63, 0xd3, 0x7f, 0x8f, 0x2d, 0x51, 0xca, 0xfb, 0xba,
+            0x92, 0x8a, 0xaa, 0x9e, 0x22, 0x0b, 0x8b, 0xbc, 0x66, 0x05, 0x71, 0x49,
+            0x9c, 0x03, 0x62, 0x8a, 0x38, 0x51, 0xb8, 0xce,
+        ]);
+
+        assert_eq!(asset_id, liquid_regtest_assetid);
+
+        let liquidv1_params = NetworkParams::liquidv1();
+        let asset_id = AssetId::pegged_asset_id_for_params_and_parent_chain_hash(
+            &liquidv1_params,
+            bitcoin::Network::Bitcoin.chain_hash(),
+        );
+
+        assert_eq!(asset_id, AssetId::LIQUID_BTC);
+
+        let liquidtestnet_params = NetworkParams::liquidtestnet();
+        let asset_id = AssetId::pegged_asset_id_for_params_and_parent_chain_hash(
+            &liquidtestnet_params,
+            ChainHash::from([0u8; 32]),
+        );
+
+        assert_eq!(asset_id, AssetId::LIQUIDTESTNET_BTC);
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index be35ef01..ea5b713f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,59 +24,97 @@
 #![deny(non_snake_case)]
 #![deny(unused_mut)]
 #![deny(missing_docs)]
+#![allow(clippy::manual_range_contains)] // this lint is bullshit
 
+/// Re-export of bitcoin crate
 pub extern crate bitcoin;
-#[macro_use]
-extern crate bitcoin_hashes as just_imported_for_the_macros;
-extern crate slip21;
+/// Re-export of bitcoin-consensus-encoding crate
+pub extern crate encoding;
+/// Re-export of `bitcoin_hashes` crate
+pub extern crate hashes;
+/// Re-export of hex crate
+pub extern crate hex;
+/// Re-export of secp256k1-zkp crate
 pub extern crate secp256k1_zkp;
-#[cfg(feature = "serde")] #[macro_use] extern crate actual_serde as serde;
-#[cfg(all(test, feature = "serde"))] extern crate serde_test;
+/// Re-export of serde crate
+#[cfg(feature = "serde")]
+pub extern crate serde;
+#[cfg(all(test, feature = "serde"))]
+extern crate serde_test;
 
-#[cfg(test)] extern crate rand;
-#[cfg(test)] extern crate bincode;
-#[cfg(any(test, feature = "serde_json"))] extern crate serde_json;
+#[cfg(test)]
+extern crate bincode;
+#[cfg(test)]
+extern crate rand;
+#[cfg(any(test, feature = "serde_json"))]
+extern crate serde_json;
 
-#[macro_use] mod internal_macros;
+#[macro_use]
+mod internal_macros;
 pub mod address;
 pub mod blech32;
+mod blind;
 mod block;
 pub mod confidential;
 pub mod dynafed;
 pub mod encode;
 mod error;
+mod ext;
 mod fast_merkle_root;
 pub mod hash_types;
-pub mod locktime;
 pub mod issuance;
+pub mod locktime;
 pub mod opcodes;
-pub mod script;
-mod transaction;
-mod blind;
 mod parse;
-pub mod slip77;
-pub mod sighash;
 pub mod pset;
-pub mod taproot;
 pub mod schnorr;
-#[cfg(feature = "serde")]
-mod serde_utils;
+pub mod script;
+pub mod sighash;
+pub mod taproot;
+mod transaction;
 // consider making upstream public
 mod endian;
-// re-export bitcoin deps which we re-use
-pub use bitcoin::{bech32, hashes};
+pub mod genesis;
+
 // export everything at the top level so it can be used as `elements::Transaction` etc.
-pub use crate::address::{Address, AddressParams, AddressError};
-pub use crate::transaction::{OutPoint, PeginData, PegoutData, EcdsaSigHashType, TxIn, TxOut, TxInWitness, TxOutWitness, Transaction, AssetIssuance};
-pub use crate::transaction::Sequence;
-pub use crate::blind::{ConfidentialTxOutError, TxOutSecrets, SurjectionInput, TxOutError, VerificationError, BlindError, UnblindError, BlindValueProofs, BlindAssetProofs};
-pub use crate::block::{BlockHeader, Block};
-pub use crate::block::ExtData as BlockExtData;
-pub use ::bitcoin::consensus::encode::VarInt;
+use internals::array_vec::ArrayVec;
+
+pub use crate::address::{Address, AddressError, AddressParams};
+pub use crate::blind::{
+    BlindError, ConfidentialTxOutError, CtLocation, CtLocationType, RangeProofMessage,
+    SurjectionInput, TxOutError, TxOutSecrets, UnblindError, VerificationError,
+};
+pub use crate::block::{Block, BlockHeader, DynafedRoot, ExtData as BlockExtData};
+pub use crate::confidential::{RangeProof, SurjectionProof};
+pub use crate::ext::{ReadExt, WriteExt};
 pub use crate::fast_merkle_root::fast_merkle_root;
 pub use crate::hash_types::*;
-pub use crate::issuance::{AssetId, ContractHash};
-pub use crate::locktime::{LockTime, PackedLockTime};
-pub use crate::script::Script;
-pub use crate::sighash::SchnorrSigHashType;
+pub use crate::issuance::{
+    AssetBlindingNonce, AssetBlindingNonceDecoder, AssetBlindingNonceDecoderError,
+    AssetBlindingNonceEncoder, AssetEntropy, AssetEntropyDecoder, AssetEntropyDecoderError,
+    AssetEntropyEncoder, AssetId, AssetIdDecoder, AssetIdDecoderError, AssetIdEncoder,
+    ContractHash,
+};
+pub use crate::locktime::LockTime;
 pub use crate::schnorr::{SchnorrSig, SchnorrSigError};
+pub use crate::script::Script;
+pub use crate::sighash::SchnorrSighashType;
+pub use crate::transaction::{
+    AssetIssuance, AssetIssuanceDecoder, AssetIssuanceDecoderError, AssetIssuanceEncoder,
+    EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder, PeginWitness,
+    PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData, Sequence,
+    SequenceDecoder, SequenceDecoderError, SequenceEncoder, Transaction, TransactionDecoder,
+    TransactionDecoderError, TransactionEncoder, TxIn, TxInDecoder, TxInDecoderError, TxInEncoder,
+    TxInWitness, TxInWitnessDecoder, TxInWitnessDecoderError, TxInWitnessEncoder, TxOut,
+    TxOutDecoder, TxOutDecoderError, TxOutEncoder, TxOutWitness, TxOutWitnessDecoder,
+    TxOutWitnessDecoderError, TxOutWitnessEncoder, Witness, WitnessDecoder, WitnessDecoderError,
+    WitnessEncoder,
+};
+
+// Encode a compact size to a slice without allocating
+pub(crate) fn compact_size_encode(value: usize) -> ArrayVec<u8, 9> {
+    use crate::encoding::Encoder as _;
+
+    let encoder = encoding::CompactSizeEncoder::new(value);
+    ArrayVec::from_slice(encoder.current_chunk())
+}
diff --git a/src/locktime.rs b/src/locktime.rs
index c5a1d6df..40b58ae3 100644
--- a/src/locktime.rs
+++ b/src/locktime.rs
@@ -11,7 +11,7 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
-//! Provides type [`LockTime`] that implements the logic around nLockTime/OP_CHECKLOCKTIMEVERIFY.
+//! 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`.
@@ -22,6 +22,7 @@ use std::cmp::{PartialOrd, Ordering};
 use std::convert::TryFrom;
 use std::str::FromStr;
 use std::io::{Read, Write};
+use crate::encoding;
 use crate::error::ParseIntError;
 use crate::parse;
 
@@ -42,117 +43,10 @@ use crate::parse::impl_parse_str_through_int;
 /// [Bitcoin Core]: https://github.com/bitcoin/bitcoin/blob/9ccaee1d5e2e4b79b0a7c29aadb41b97e4741332/src/script/script.h#L39
 pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
 
-/// Packed lock time wraps a [`LockTime`] consensus value i.e., the raw `u32` used by the network.
-///
-/// This struct may be preferred in performance-critical applications because it's slightly smaller
-/// than [`LockTime`] and has a bit more performant (de)serialization. In particular, this may be
-/// relevant when the value is not processed, just passed around. Note however that the difference
-/// is super-small, so unless you do something extreme you shouldn't worry about it.
-///
-/// This type implements a naive ordering based on the `u32`, this is _not_ a semantically correct
-/// ordering for a lock time, hence [`LockTime`] does not implement `Ord`. This type is useful if
-/// you want to use a lock time as part of a struct and wish to derive `Ord`. For all other uses,
-/// consider using [`LockTime`] directly.
-///
-/// # Examples
-/// ```
-/// # use bitcoin::{Amount, PackedLockTime, LockTime};
-/// #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-/// struct S {
-///     lock_time: PackedLockTime,
-///     amount: Amount,
-/// }
-///
-/// let _ = S {
-///     lock_time: LockTime::from_consensus(741521).into(),
-///     amount: Amount::from_sat(10_000_000),
-/// };
-/// ```
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
-pub struct PackedLockTime(pub u32);
-
-impl PackedLockTime {
-    /// If [`crate::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: PackedLockTime = PackedLockTime(0);
-
-    /// Returns the inner `u32`.
-    #[inline]
-    pub fn to_u32(self) -> u32 {
-        self.0
-    }
-}
-
-impl fmt::Display for PackedLockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl Encodable for PackedLockTime {
-    #[inline]
-    fn consensus_encode<W: Write>(&self, w: W) -> Result<usize, encode::Error> {
-        self.0.consensus_encode(w)
-    }
-}
-
-impl Decodable for PackedLockTime {
-    #[inline]
-    fn consensus_decode<R: Read>(r: R) -> Result<Self, encode::Error> {
-        u32::consensus_decode(r).map(PackedLockTime)
-    }
-}
-
-impl From<LockTime> for PackedLockTime {
-    fn from(n: LockTime) -> Self {
-        PackedLockTime(n.to_consensus_u32())
-    }
-}
-
-impl From<PackedLockTime> for LockTime {
-    fn from(n: PackedLockTime) -> Self {
-        LockTime::from_consensus(n.0)
-    }
-}
-
-impl From<&LockTime> for PackedLockTime {
-    fn from(n: &LockTime) -> Self {
-        PackedLockTime(n.to_consensus_u32())
-    }
-}
-
-impl From<&PackedLockTime> for LockTime {
-    fn from(n: &PackedLockTime) -> Self {
-        LockTime::from_consensus(n.0)
-    }
-}
-
-impl From<PackedLockTime> for u32 {
-    fn from(p: PackedLockTime) -> Self {
-        p.0
-    }
-}
-
-impl_parse_str_through_int!(PackedLockTime);
-
-impl fmt::LowerHex for PackedLockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:x}", self.0)
-    }
-}
-
-impl fmt::UpperHex for PackedLockTime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:X}", self.0)
-    }
-}
-
 /// A 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 [`crate::Transaction::lock_time`]
-/// in this library) and also for the argument to opcode 'OP_CHECKLOCKTIMEVERIFY`.
+/// in this library) and also for the argument to opcode `OP_CHECKLOCKTIMEVERIFY`.
 ///
 /// ### Relevant BIPs
 ///
@@ -161,26 +55,24 @@ impl fmt::UpperHex for PackedLockTime {
 ///
 /// # Examples
 /// ```
-/// # use bitcoin::{LockTime, LockTime::*};
+/// # use elements::LockTime;
 /// # let n = LockTime::from_consensus(100);          // n OP_CHECKLOCKTIMEVERIFY
 /// # let lock_time = LockTime::from_consensus(100);  // nLockTime
 /// // To compare lock times there are various `is_satisfied_*` methods, you may also use:
 /// let is_satisfied = match (n, lock_time) {
-///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
-///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+///     (LockTime::Blocks(n), LockTime::Blocks(lock_time)) => n <= lock_time,
+///     (LockTime::Seconds(n), LockTime::Seconds(lock_time)) => n <= lock_time,
 ///     _ => panic!("handle invalid comparison error"),
 /// };
 /// ```
 #[allow(clippy::derive_ord_xor_partial_ord)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 pub enum LockTime {
     /// A block height lock time value.
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::LockTime;
+    /// use elements::LockTime;
     ///
     /// let block: u32 = 741521;
     /// let n = LockTime::from_height(block).expect("valid height");
@@ -192,7 +84,7 @@ pub enum LockTime {
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::LockTime;
+    /// use elements::LockTime;
     ///
     /// let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
     /// let n = LockTime::from_time(seconds).expect("valid time");
@@ -207,13 +99,13 @@ impl LockTime {
     /// transaction with nLocktime==0 is able to be included immediately in any block.
     pub const ZERO: LockTime = LockTime::Blocks(Height(0));
 
-    /// Constructs a `LockTime` from an nLockTime value or the argument to OP_CHEKCLOCKTIMEVERIFY.
+    /// Constructs a `LockTime` from an nLockTime value or the argument to `OP_CHEKCLOCKTIMEVERIFY`.
     ///
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin::LockTime;
-    /// # let n = LockTime::from_consensus(741521); // n OP_CHECKLOCKTIMEVERIFY
+    /// use elements::LockTime;
+    /// let n = LockTime::from_consensus(741521); // n OP_CHECKLOCKTIMEVERIFY
     ///
     /// // `from_consensus` roundtrips as expected with `to_consensus_u32`.
     /// let n_lock_time: u32 = 741521;
@@ -234,7 +126,7 @@ impl LockTime {
     ///
     /// # Examples
     /// ```rust
-    /// # use bitcoin::LockTime;
+    /// use elements::LockTime;
     /// assert!(LockTime::from_height(741521).is_ok());
     /// assert!(LockTime::from_height(1653195600).is_err());
     /// ```
@@ -250,7 +142,7 @@ impl LockTime {
     ///
     /// # Examples
     /// ```rust
-    /// # use bitcoin::LockTime;
+    /// use elements::LockTime;
     /// assert!(LockTime::from_time(1653195600).is_ok());
     /// assert!(LockTime::from_time(741521).is_err());
     /// ```
@@ -292,7 +184,7 @@ impl LockTime {
     ///
     /// # Examples
     /// ```no_run
-    /// # use bitcoin::blockdata::locktime::{LockTime, Height, Time};
+    /// # use elements::locktime::{LockTime, Height, Time};
     /// // Can be implemented if block chain data is available.
     /// fn get_height() -> Height { todo!("return the current block height") }
     /// fn get_time() -> Time { todo!("return the current block time") }
@@ -304,11 +196,9 @@ impl LockTime {
     /// ````
     #[inline]
     pub fn is_satisfied_by(&self, height: Height, time: Time) -> bool {
-        use LockTime::*;
-
         match *self {
-            Blocks(n) => n <= height,
-            Seconds(n) => n <= time,
+            LockTime::Blocks(n) => n <= height,
+            LockTime::Seconds(n) => n <= time,
         }
     }
 
@@ -323,13 +213,13 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin::{LockTime, LockTime::*};
+    /// # use elements::LockTime;
     /// # let n = LockTime::from_consensus(100);          // n OP_CHECKLOCKTIMEVERIFY
     /// # let lock_time = LockTime::from_consensus(100);  // nLockTime
     ///
     /// let is_satisfied = match (n, lock_time) {
-    ///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
-    ///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+    ///     (LockTime::Blocks(n), LockTime::Blocks(lock_time)) => n <= lock_time,
+    ///     (LockTime::Seconds(n), LockTime::Seconds(lock_time)) => n <= lock_time,
     ///     _ => panic!("invalid comparison"),
     /// };
     ///
@@ -361,11 +251,9 @@ impl From<Time> for LockTime {
 
 impl PartialOrd for LockTime {
     fn partial_cmp(&self, other: &LockTime) -> Option<Ordering> {
-        use LockTime::*;
-
         match (*self, *other) {
-            (Blocks(ref a), Blocks(ref b)) => a.partial_cmp(b),
-            (Seconds(ref a), Seconds(ref b)) => a.partial_cmp(b),
+            (Self::Blocks(ref a), Self::Blocks(ref b)) => a.partial_cmp(b),
+            (Self::Seconds(ref a), Self::Seconds(ref b)) => a.partial_cmp(b),
             (_, _) => None,
         }
     }
@@ -373,22 +261,50 @@ impl PartialOrd for LockTime {
 
 impl fmt::Display for LockTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime::*;
-
         if f.alternate() {
             match *self {
-                Blocks(ref h) => write!(f, "block-height {}", h),
-                Seconds(ref t) => write!(f, "block-time {} (seconds since epoch)", t),
+                Self::Blocks(ref h) => write!(f, "block-height {}", h),
+                Self::Seconds(ref t) => write!(f, "block-time {} (seconds since epoch)", t),
             }
         } else {
             match *self {
-                Blocks(ref h) => fmt::Display::fmt(h, f),
-                Seconds(ref t) => fmt::Display::fmt(t, f),
+                Self::Blocks(ref h) => fmt::Display::fmt(h, f),
+                Self::Seconds(ref t) => fmt::Display::fmt(t, f),
             }
         }
     }
 }
 
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`LockTime`] type.
+    pub struct LockTimeEncoder<'e>(encoding::ArrayEncoder<4>);
+}
+
+impl encoding::Encode for LockTime {
+    type Encoder<'e> = LockTimeEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        LockTimeEncoder::new(encoding::ArrayEncoder::without_length_prefix(self.to_consensus_u32().to_le_bytes()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`LockTime`] type.
+    #[derive(Default)]
+    pub struct LockTimeDecoder(encoding::ArrayDecoder<4>);
+
+    /// Decoder error for the [`LockTime`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct LockTimeDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "failed to decode locktime";
+
+    impl Decode for LockTime {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(LockTime::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
 impl Encodable for LockTime {
     #[inline]
     fn consensus_encode<W: Write>(&self, w: W) -> Result<usize, encode::Error> {
@@ -406,11 +322,12 @@ impl Decodable for LockTime {
 
 /// An absolute block height, guaranteed to always contain a valid height value.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 pub struct Height(u32);
 
 impl Height {
+    /// Height zero
+    pub const ZERO: Self = Height(0);
+
     /// Constructs a new block height.
     ///
     /// # Errors
@@ -419,7 +336,7 @@ impl Height {
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::blockdata::locktime::Height;
+    /// use elements::locktime::Height;
     ///
     /// let h: u32 = 741521;
     /// let height = Height::from_consensus(h).expect("invalid height value");
@@ -438,7 +355,7 @@ impl Height {
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::LockTime;
+    /// use elements::LockTime;
     ///
     /// let n_lock_time: u32 = 741521;
     /// let lock_time = LockTime::from_consensus(n_lock_time);
@@ -489,8 +406,6 @@ impl TryFrom<String> for Height {
 /// `to_consensus_u32()`. Said another way, `Time(x)` means 'x seconds since epoch' _not_ '(x -
 /// threshold) seconds since epoch'.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 pub struct Time(u32);
 
 impl Time {
@@ -502,7 +417,7 @@ impl Time {
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::blockdata::locktime::Time;
+    /// use elements::locktime::Time;
     ///
     /// let t: u32 = 1653195600; // May 22nd, 5am UTC.
     /// let time = Time::from_consensus(t).expect("invalid time value");
@@ -521,7 +436,7 @@ impl Time {
     ///
     /// # Examples
     /// ```rust
-    /// use bitcoin::LockTime;
+    /// use elements::LockTime;
     ///
     /// let n_lock_time: u32 = 1653195600; // May 22nd, 5am UTC.
     /// let lock_time = LockTime::from_consensus(n_lock_time);
@@ -590,26 +505,20 @@ pub enum Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::Error::*;
-
         match *self {
-            Conversion(ref e) => write_err!(f, "error converting lock time value"; e),
-            Operation(ref e) => write_err!(f, "error during lock time operation"; e),
-            Parse(ref e) => write_err!(f, "failed to parse lock time from string"; e),
+            Self::Conversion(ref e) => write_err!(f, "error converting lock time value"; e),
+            Self::Operation(ref e) => write_err!(f, "error during lock time operation"; e),
+            Self::Parse(ref e) => write_err!(f, "failed to parse lock time from string"; e),
         }
     }
 }
 
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use self::Error::*;
-
         match *self {
-            Conversion(ref e) => Some(e),
-            Operation(ref e) => Some(e),
-            Parse(ref e) => Some(e),
+            Self::Conversion(ref e) => Some(e),
+            Self::Operation(ref e) => Some(e),
+            Self::Parse(ref e) => Some(e),
         }
     }
 }
@@ -665,8 +574,6 @@ impl fmt::Display for ConversionError {
     }
 }
 
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for ConversionError {}
 
 /// Describes the two types of locking, lock-by-blockheight and lock-by-blocktime.
@@ -680,11 +587,9 @@ enum LockTimeUnit {
 
 impl fmt::Display for LockTimeUnit {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTimeUnit::*;
-
         match *self {
-            Blocks => write!(f, "expected lock-by-blockheight (must be < {})", LOCK_TIME_THRESHOLD),
-            Seconds => write!(f, "expected lock-by-blocktime (must be >= {})", LOCK_TIME_THRESHOLD),
+            Self::Blocks => write!(f, "expected lock-by-blockheight (must be < {})", LOCK_TIME_THRESHOLD),
+            Self::Seconds => write!(f, "expected lock-by-blocktime (must be >= {})", LOCK_TIME_THRESHOLD),
         }
     }
 }
@@ -699,16 +604,12 @@ pub enum OperationError {
 
 impl fmt::Display for OperationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::OperationError::*;
-
         match *self {
-            InvalidComparison => f.write_str("cannot compare different lock units (height vs time)"),
+            Self::InvalidComparison => f.write_str("cannot compare different lock units (height vs time)"),
         }
     }
 }
 
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for OperationError {}
 
 #[cfg(test)]
diff --git a/src/opcodes.rs b/src/opcodes.rs
index 526ee447..d9cfec5b 100644
--- a/src/opcodes.rs
+++ b/src/opcodes.rs
@@ -20,8 +20,6 @@
 
 #![allow(non_camel_case_types)]
 
-#[cfg(feature = "serde")] use serde;
-
 use std::fmt;
 
 // Note: I am deliberately not implementing PartialOrd or Ord on the
@@ -196,45 +194,45 @@ pub mod all {
     pub const OP_PUSHDATA2: All = All {code: 0x4d};
     /// Read the next 4 bytes as N; push the next N bytes as an array onto the stack
     pub const OP_PUSHDATA4: All = All {code: 0x4e};
-    /// Push the array [0x81] onto the stack
+    /// Push the array `[0x81]` onto the stack
     pub const OP_PUSHNUM_NEG1: All = All {code: 0x4f};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RESERVED: All = All {code: 0x50};
-    /// Push the array [0x01] onto the stack
+    /// Push the array `[0x01]` onto the stack
     pub const OP_PUSHNUM_1: All = All {code: 0x51};
-    /// Push the array [0x02] onto the stack
+    /// Push the array `[0x02]` onto the stack
     pub const OP_PUSHNUM_2: All = All {code: 0x52};
-    /// Push the array [0x03] onto the stack
+    /// Push the array `[0x03]` onto the stack
     pub const OP_PUSHNUM_3: All = All {code: 0x53};
-    /// Push the array [0x04] onto the stack
+    /// Push the array `[0x04]` onto the stack
     pub const OP_PUSHNUM_4: All = All {code: 0x54};
-    /// Push the array [0x05] onto the stack
+    /// Push the array `[0x05]` onto the stack
     pub const OP_PUSHNUM_5: All = All {code: 0x55};
-    /// Push the array [0x06] onto the stack
+    /// Push the array `[0x06]` onto the stack
     pub const OP_PUSHNUM_6: All = All {code: 0x56};
-    /// Push the array [0x07] onto the stack
+    /// Push the array `[0x07]` onto the stack
     pub const OP_PUSHNUM_7: All = All {code: 0x57};
-    /// Push the array [0x08] onto the stack
+    /// Push the array `[0x08]` onto the stack
     pub const OP_PUSHNUM_8: All = All {code: 0x58};
-    /// Push the array [0x09] onto the stack
+    /// Push the array `[0x09]` onto the stack
     pub const OP_PUSHNUM_9: All = All {code: 0x59};
-    /// Push the array [0x0a] onto the stack
+    /// Push the array `[0x0a]` onto the stack
     pub const OP_PUSHNUM_10: All = All {code: 0x5a};
-    /// Push the array [0x0b] onto the stack
+    /// Push the array `[0x0b]` onto the stack
     pub const OP_PUSHNUM_11: All = All {code: 0x5b};
-    /// Push the array [0x0c] onto the stack
+    /// Push the array `[0x0c]` onto the stack
     pub const OP_PUSHNUM_12: All = All {code: 0x5c};
-    /// Push the array [0x0d] onto the stack
+    /// Push the array `[0x0d]` onto the stack
     pub const OP_PUSHNUM_13: All = All {code: 0x5d};
-    /// Push the array [0x0e] onto the stack
+    /// Push the array `[0x0e]` onto the stack
     pub const OP_PUSHNUM_14: All = All {code: 0x5e};
-    /// Push the array [0x0f] onto the stack
+    /// Push the array `[0x0f]` onto the stack
     pub const OP_PUSHNUM_15: All = All {code: 0x5f};
-    /// Push the array [0x10] onto the stack
+    /// Push the array `[0x10]` onto the stack
     pub const OP_PUSHNUM_16: All = All {code: 0x60};
     /// Does nothing
     pub const OP_NOP: All = All {code: 0x61};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_VER: All = All {code: 0x62};
     /// Pop and execute the next statements if a nonzero element was popped
     pub const OP_IF: All = All {code: 0x63};
@@ -244,8 +242,8 @@ pub mod all {
     pub const OP_VERIF: All = All {code: 0x65};
     /// Fail the script unconditionally, does not even need to be executed
     pub const OP_VERNOTIF: All = All {code: 0x66};
-    /// 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.
+    /// 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.
     pub const OP_ELSE: All = All {code: 0x67};
     /// Pop and execute the next statements if a zero element was popped
     pub const OP_ENDIF: All = All {code: 0x68};
@@ -264,10 +262,10 @@ pub mod all {
     /// Duplicates the two three stack items as ABC -> ABCABC
     pub const OP_3DUP: All = All {code: 0x6f};
     /// Copies the two stack items of items two spaces back to
-    /// the front, as xxAB -> ABxxAB
+    /// the front, as xxAB -> `ABxxAB`
     pub const OP_2OVER: All = All {code: 0x70};
     /// Moves the two stack items four spaces back to the front,
-    /// as xxxxAB -> ABxxxx
+    /// as xxxxAB -> `ABxxxx`
     pub const OP_2ROT: All = All {code: 0x71};
     /// Swaps the top two pairs, as ABCD -> CDAB
     pub const OP_2SWAP: All = All {code: 0x72};
@@ -281,7 +279,7 @@ pub mod all {
     pub const OP_DUP: All = All {code: 0x76};
     /// Drops the second-to-top stack item
     pub const OP_NIP: All = All {code: 0x77};
-    /// Copies the second-to-top stack item, as xA -> AxA
+    /// Copies the second-to-top stack item, as xA -> `AxA`
     pub const OP_OVER: All = All {code: 0x78};
     /// Pop the top stack element as N. Copy the Nth stack element to the top
     pub const OP_PICK: All = All {code: 0x79};
@@ -315,9 +313,9 @@ pub mod all {
     pub const OP_EQUAL: All = All {code: 0x87};
     /// Returns success if the inputs are exactly equal, failure otherwise
     pub const OP_EQUALVERIFY: All = All {code: 0x88};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RESERVED1: All = All {code: 0x89};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RESERVED2: All = All {code: 0x8a};
     /// Increment the top stack element in place
     pub const OP_1ADD: All = All {code: 0x8b};
@@ -385,9 +383,9 @@ pub mod all {
     pub const OP_HASH256: All = All {code: 0xaa};
     /// Ignore this and everything preceding when deciding what to sign when signature-checking
     pub const OP_CODESEPARATOR: All = All {code: 0xab};
-    /// https://en.bitcoin.it/wiki/OP_CHECKSIG pushing 1/0 for success/failure
+    /// <https://en.bitcoin.it/wiki/OP_CHECKSIG> pushing 1/0 for success/failure
     pub const OP_CHECKSIG: All = All {code: 0xac};
-    /// https://en.bitcoin.it/wiki/OP_CHECKSIG returning success/failure
+    /// <https://en.bitcoin.it/wiki/OP_CHECKSIG> returning success/failure
     pub const OP_CHECKSIGVERIFY: All = All {code: 0xad};
     /// 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
@@ -396,9 +394,9 @@ pub mod all {
     pub const OP_CHECKMULTISIGVERIFY: All = All {code: 0xaf};
     /// Does nothing
     pub const OP_NOP1: All = All {code: 0xb0};
-    /// https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki
+    /// <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
     pub const OP_CLTV: All = All {code: 0xb1};
-    /// https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki
+    /// <https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki>
     pub const OP_CSV: All = All {code: 0xb2};
     /// Does nothing
     pub const OP_NOP4: All = All {code: 0xb3};
@@ -415,19 +413,19 @@ pub mod all {
     /// Does nothing
     pub const OP_NOP10: All = All {code: 0xb9};
     // Every other opcode acts as OP_RETURN
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_CHECKSIGADD: All = All {code: 0xba};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_187: All = All {code: 0xbb};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_188: All = All {code: 0xbc};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_189: All = All {code: 0xbd};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_190: All = All {code: 0xbe};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_191: All = All {code: 0xbf};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_192: All = All {code: 0xc0};
     /// Check a signature on a given hash with a given public key
     pub const OP_CHECKSIGFROMSTACK: All = All {code: 0xc1};
@@ -447,165 +445,186 @@ pub mod all {
     /// and finally pushes a SHA256 hash value after adding the bytestring
     /// and completing the padding
     pub const OP_SHA256FINALIZE: All = All {code: 0xc6};
-    /// Pop a CScriptNum input index idx and push the outpoint as a tuple.
-    /// First push the txid(32) of the prev_out, followed by a 4 byte push of
-    /// vout followed by a push for the outpoint_flag(1)
+    /// Pop a `CScriptNum` input index idx and push the outpoint as a tuple.
+    ///
+    /// First push the txid(32) of the `prev_out`, followed by a 4 byte push of
+    /// vout followed by a push for the `outpoint_flag(1)`
     pub const OP_INSPECTINPUTOUTPOINT: All = All {code: 0xc7};
-    /// Pop a CScriptNum input index idx and push the nAsset onto the stack as two elements.
+    /// Pop a `CScriptNum` input index idx and push the nAsset onto the stack as two elements.
+    ///
     /// The first push the assetID(32), followed by the prefix(1)
     pub const OP_INSPECTINPUTASSET: All = All {code: 0xc8};
-    /// Pop a CScriptNum input index idx and push the nValue as a tuple,
+    /// Pop a `CScriptNum` input index idx and push the nValue as a tuple,
+    ///
     /// value(8 byte LE, 32) followed by prefix(1),
     pub const OP_INSPECTINPUTVALUE: All = All {code: 0xc9};
-    /// Pop a CScriptNum input index idx and push the following depending the type of scriptPubkey:
+    /// Pop a `CScriptNum` input index idx and push the following depending the type of scriptPubkey:
+    ///
     /// - If the scriptPubKey is not a native segwit program, push a single sha256
-    /// hash of the scriptPubKey on stack top. Next, push a CScriptNum(-1) to
-    /// indicate a non-native segwit scriptPubKey.
+    ///   hash of the scriptPubKey on stack top. Next, push a CScriptNum(-1) to
+    ///   indicate a non-native segwit scriptPubKey.
     /// - If the scriptPubKey is a native segwit program, push the witness program(2-40)
-    /// followed by a push for segwit version(0-1).
+    ///   followed by a push for segwit version(0-1).
     pub const OP_INSPECTINPUTSCRIPTPUBKEY: All = All {code: 0xca};
-    /// Pop a CScriptNum input index idx and push the nSequence(4) as little-endian number.
+    /// Pop a `CScriptNum` input index idx and push the nSequence(4) as little-endian number.
     pub const OP_INSPECTINPUTSEQUENCE: All = All {code: 0xcb};
-    /// Pop a CScriptNum input index idx and push the assetIssuance information if the asset has issuance,
-    /// otherwise push an empty vector. Refer to the [spec](https://github.com/ElementsProject/elements/blob/master/doc/tapscript_opcodes.md)
+    /// Pop a `CScriptNum` input index idx and push the assetIssuance information if the asset has issuance,
+    /// otherwise push an empty vector.
+    ///
+    /// Refer to the [spec](https://github.com/ElementsProject/elements/blob/master/doc/tapscript_opcodes.md)
     /// for details
     pub const OP_INSPECTINPUTISSUANCE: All = All {code: 0xcc};
-    /// Pushes the current input index as CScriptNum. This can be used in conjunction with
+    /// Pushes the current input index as `CScriptNum`. This can be used in conjunction with
     /// input introspection opcodes for inspecting current input.
     pub const OP_PUSHCURRENTINPUTINDEX: All = All {code: 0xcd};
-    /// Pop a CScriptNum input index idx and push the nAsset as a tuple,
+    /// Pop a `CScriptNum` input index idx and push the nAsset as a tuple,
     /// first push the assetID(32), followed by the prefix(1)
     pub const OP_INSPECTOUTPUTASSET: All = All {code: 0xce};
-    /// Pop a CScriptNum input index idx and push the nValue as a tuple,
+    /// Pop a `CScriptNum` input index idx and push the nValue as a tuple,
     /// value(8 byte LE, 32) followed by prefix
     pub const OP_INSPECTOUTPUTVALUE: All = All {code: 0xcf};
-    /// Pop a CScriptNum input index idx and push the nNonce(33) onto the stack.
+    /// Pop a `CScriptNum` input index idx and push the nNonce(33) onto the stack.
     /// If the nonce is null, push an empty vector onto the stack
     pub const OP_INSPECTOUTPUTNONCE: All = All {code: 0xd0};
-    /// Pop a CScriptNum input index idx and push the scriptPubkey onto the stack.
+    /// Pop a `CScriptNum` input index idx and push the scriptPubkey onto the stack.
     /// Similar to [`OP_INSPECTINPUTSCRIPTPUBKEY`], for this output.
     pub const OP_INSPECTOUTPUTSCRIPTPUBKEY: All = All {code: 0xd1};
     /// Push the nVersion(4) as little-endian.
     pub const OP_INSPECTVERSION: All = All {code: 0xd2};
     /// Push the nLockTime(4) as little-endian.
     pub const OP_INSPECTLOCKTIME: All = All {code: 0xd3};
-    /// Push the number of inputs as CScriptNum
+    /// Push the number of inputs as `CScriptNum`
     pub const OP_INSPECTNUMINPUTS: All = All {code: 0xd4};
-    /// Push the number of outputs as CScriptNum
+    /// Push the number of outputs as `CScriptNum`
     pub const OP_INSPECTNUMOUTPUTS: All = All {code: 0xd5};
     /// Push the transaction weight (8) as little-endian
     pub const OP_TXWEIGHT: All = All {code: 0xd6};
     /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
-    /// Push a + b onto the stack. Push 1 CScriptNum if there is no overflow.
+    ///
+    /// Push a + b onto the stack. Push 1 `CScriptNum` if there is no overflow.
     /// Refer to the spec for details when dealing with overflow.
     pub const OP_ADD64: All = All {code: 0xd7};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
-    /// Push a - b onto the stack. Push 1 CScriptNum if there is no overflow.
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
+    ///
+    /// Push a - b onto the stack. Push 1 `CScriptNum` if there is no overflow.
     /// Refer to the spec for details when dealing with overflow.
     pub const OP_SUB64: All = All {code: 0xd8};
     /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
-    /// Push a*b onto the stack. Push 1 CScriptNum if there is no overflow.
+    ///
+    /// Push a*b onto the stack. Push 1 `CScriptNum` if there is no overflow.
     /// Refer to the spec for details when dealing with overflow.
     pub const OP_MUL64: All = All {code: 0xd9};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE).
+    ///
     /// First push remainder a%b(must be non-negative and less than |b|) onto the
     /// stack followed by quotient(a//b) onto the stack.
     ///
     /// If b==0 or a = -2<sup>63</sup> && b = -1, treat as overflow.
-    /// Push 1 CScriptNum if there is no overflow.
+    /// Push 1 `CScriptNum` if there is no overflow.
     /// Refer to the spec for details when dealing with overflow.
     pub const OP_DIV64: All = All {code: 0xda};
     /// Pop the first number(8 byte LE) as a and pushes -a on the stack top.
-    /// If the number is -2^63 treat as overflow, otherwise push CScriptNum 1 to indicate no overflow.
+    ///
+    /// If the number is -2^63 treat as overflow, otherwise push `CScriptNum` 1 to indicate no overflow.
     /// Refer to the spec for details when dealing with overflow.
     pub const OP_NEG64: All = All {code: 0xdb};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a < b.
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a < b.
+    ///
     /// Note that this operation cannot fail
     pub const OP_LESSTHAN64: All = All {code: 0xdc};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a <= b.
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a <= b.
+    ///
     /// Note that this operation cannot fail
     pub const OP_LESSTHANOREQUAL64: All = All {code: 0xdd};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a > b
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a > b.
+    ///
     /// Note that this operation cannot fail
     pub const OP_GREATERTHAN64: All = All {code: 0xde};
-    /// pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a >= b.
+    /// Pop the first number(8 byte LE) as b followed another pop for a(8 byte LE). Push a >= b.
     /// Note that this operation cannot fail
     pub const OP_GREATERTHANOREQUAL64: All = All {code: 0xdf};
-    /// pop the stack as minimal CSciptNum, push 8 byte signed LE corresponding to that number.
+    /// Pop the stack as minimal `CScriptNum`, push 8 byte signed LE corresponding to that number.
     pub const OP_SCRIPTNUMTOLE64: All = All {code: 0xe0};
-    /// pop the stack as a 8 byte signed LE. Convert to CScriptNum and push it, abort on fail.
+    /// Pop the stack as a 8 byte signed LE. Convert to `CScriptNum` and push it, abort on fail.
+    ///
     /// Please check the range of the operand before calling the opcode.
     pub const OP_LE64TOSCRIPTNUM: All = All {code: 0xe1};
-    /// pop the stack as a 4 byte unsigned LE. Push the corresponding 8 byte signed LE number.
+    /// Pop the stack as a 4 byte unsigned LE. Push the corresponding 8 byte signed LE number.
+    ///
     /// Cannot fail, useful for operating of version, locktime, sequence, number of inputs,
     /// number of outputs, weight etc.
     pub const OP_LE32TOLE64: All = All {code: 0xe2};
-    ///  Pops three elements from stack as described below:
-    /// 1) a 32 byte big endian, unsigned scalar k.
-    /// 2) Compressed EC point P, and
-    /// 3) compressed EC point Q.
+    /// Pops three elements from stack as:
+    ///
+    /// 1. a 32 byte big endian, unsigned scalar k.
+    /// 2. Compressed EC point P, and
+    /// 3. compressed EC point Q.
+    ///
     /// Abort if P, Q is invalid or k is not 32 bytes and outside of secp256k1 curve order.
+    ///
     /// Abort if Q != k*P.
     pub const OP_ECMULSCALARVERIFY: All = All {code: 0xe3};
     /// Pop the three elements as:
-    /// 1) 32 byte X-only internal key P,
-    /// 2) a 32 byte big endian, unsigned scalar k, and
-    /// 3) 33 byte compressed point Q.
+    ///
+    /// 1. 32 byte X-only internal key P,
+    /// 2. a 32 byte big endian, unsigned scalar k, and
+    /// 3. 33 byte compressed point Q.
     ///
     /// Abort if P, Q is invalid or k is not 32 bytes and outside of secp256k1 curve order.
+    ///
     /// Abort if Q != P + k*G where G is the generator for secp256k1.
     pub const OP_TWEAKVERIFY: All = All {code: 0xe4};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_229: All = All {code: 0xe5};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_230: All = All {code: 0xe6};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_231: All = All {code: 0xe7};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_232: All = All {code: 0xe8};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_233: All = All {code: 0xe9};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_234: All = All {code: 0xea};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_235: All = All {code: 0xeb};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_236: All = All {code: 0xec};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_237: All = All {code: 0xed};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_238: All = All {code: 0xee};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_239: All = All {code: 0xef};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_240: All = All {code: 0xf0};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_241: All = All {code: 0xf1};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_242: All = All {code: 0xf2};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_243: All = All {code: 0xf3};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_244: All = All {code: 0xf4};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_245: All = All {code: 0xf5};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_246: All = All {code: 0xf6};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_247: All = All {code: 0xf7};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_248: All = All {code: 0xf8};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_249: All = All {code: 0xf9};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_250: All = All {code: 0xfa};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_251: All = All {code: 0xfb};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_252: All = All {code: 0xfc};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_253: All = All {code: 0xfd};
-    /// Synonym for OP_RETURN
+    /// Synonym for `OP_RETURN`
     pub const OP_RETURN_254: All = All {code: 0xfe};
     /// Invalid opcode
     pub const OP_INVALIDOPCODE: All = All {code: 0xff};
@@ -767,20 +786,18 @@ pub enum ClassifyContext {
 impl All {
     /// Classifies an Opcode into a broad class.
     #[inline]
+    #[allow(clippy::wildcard_imports)] // ok to import all the opcodes with all::*
     pub fn classify(self, ctx: ClassifyContext) -> Class {
         use self::all::*;
         match (self, ctx) {
             // 3 opcodes illegal in all contexts
-            (OP_VERIF, _) | (OP_VERNOTIF, _) | (OP_INVALIDOPCODE, _) => Class::IllegalOp,
+            (OP_VERIF | OP_VERNOTIF | OP_INVALIDOPCODE, _) => Class::IllegalOp,
 
             // 15 opcodes illegal in Legacy context
-            (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,
+            (OP_CAT | OP_SUBSTR | OP_LEFT | OP_RIGHT
+            | OP_INVERT | OP_AND | OP_OR | OP_XOR
+            | OP_2MUL | OP_2DIV | OP_MUL | OP_DIV
+            | OP_MOD | OP_LSHIFT | OP_RSHIFT, ClassifyContext::Legacy) => Class::IllegalOp,
 
             // 87 opcodes of SuccessOp class only in TapScript context
             (op, ClassifyContext::TapScript)
@@ -799,27 +816,24 @@ impl All {
             (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,
+            (OP_RESERVED | OP_RESERVED1 | OP_RESERVED2 | OP_VER, 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,
+            (OP_CHECKMULTISIG | 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 + self.code as i32 - OP_PUSHNUM_1.code as i32)
+                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(self.code as u32),
+            (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::try_from_all(self).unwrap()),
@@ -846,23 +860,13 @@ impl fmt::Display for All {
     }
 }
 
-#[cfg(feature = "serde")]
-impl serde::Serialize for All {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
 /// Empty stack is also FALSE
 pub static OP_FALSE: All = all::OP_PUSHBYTES_0;
 /// Number 1 is also TRUE
 pub static OP_TRUE: All = all::OP_PUSHNUM_1;
-/// previously called OP_NOP2
+/// previously called `OP_NOP2`
 pub static OP_NOP2: All = all::OP_CLTV;
-/// previously called OP_NOP3
+/// previously called `OP_NOP3`
 pub static OP_NOP3: All = all::OP_CSV;
 
 /// Broad categories of opcodes with similar behavior
diff --git a/src/parse.rs b/src/parse.rs
index 4cea0e14..8ade3409 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -52,7 +52,7 @@ impl fmt::Display for ParseIntError {
     }
 }
 
-/// Not strictly neccessary but serves as a lint - avoids weird behavior if someone accidentally
+/// Not strictly necessary but serves as a lint - avoids weird behavior if someone accidentally
 /// passes non-integer to the `parse()` function.
 pub(crate) trait Integer: FromStr<Err=std::num::ParseIntError> + TryFrom<i8> + Sized {}
 
diff --git a/src/pset/elip100.rs b/src/pset/elip100.rs
new file mode 100644
index 00000000..d95e9166
--- /dev/null
+++ b/src/pset/elip100.rs
@@ -0,0 +1,404 @@
+//!
+//! An implementation of ELIP0100 as defined in
+//! <https://github.com/ElementsProject/ELIPs/blob/main/elip-0100.mediawiki>
+//! but excluding contract validation.
+//!
+//! ELIP0100 defines how to include assets metadata, such as the contract defining the asset and
+//! the issuance prevout inside a PSET
+//!
+//! To use check [`PartiallySignedTransaction::add_asset_metadata`] and
+//! [`PartiallySignedTransaction::get_asset_metadata`]
+//!
+
+use std::io::Cursor;
+
+use super::{raw::ProprietaryKey, PartiallySignedTransaction};
+use crate::{
+    encode::{self, Decodable, Encodable},
+    AssetId, OutPoint,
+};
+
+/// keytype as defined in ELIP0100
+pub const PSBT_ELEMENTS_HWW_GLOBAL_ASSET_METADATA: u8 = 0x00u8;
+
+/// Token keytype as defined in ELIP0100
+pub const PSBT_ELEMENTS_HWW_GLOBAL_REISSUANCE_TOKEN: u8 = 0x01u8;
+
+/// Prefix for PSET hardware wallet extension as defined in ELIP0100
+pub const PSET_HWW_PREFIX: &[u8] = b"pset_hww";
+
+/// Contains extension to add and retrieve from the PSET contract informations related to an asset
+impl PartiallySignedTransaction {
+    /// Add contract information to the PSET, returns None if it wasn't present or Some with the old
+    /// data if already in the PSET
+    pub fn add_asset_metadata(
+        &mut self,
+        asset_id: AssetId,
+        asset_meta: &AssetMetadata,
+    ) -> Option<Result<AssetMetadata, encode::Error>> {
+        let key = prop_key(&asset_id, PSBT_ELEMENTS_HWW_GLOBAL_ASSET_METADATA);
+        self.global
+            .proprietary
+            .insert(key, asset_meta.serialize())
+            .map(|old| AssetMetadata::deserialize(&old))
+    }
+
+    /// Get contract information from the PSET, returns None if there are no information regarding
+    /// the given `asset_id` in the PSET
+    pub fn get_asset_metadata(
+        &self,
+        asset_id: AssetId,
+    ) -> Option<Result<AssetMetadata, encode::Error>> {
+        let key = prop_key(&asset_id, PSBT_ELEMENTS_HWW_GLOBAL_ASSET_METADATA);
+
+        self.global
+            .proprietary
+            .get(&key)
+            .map(|data| AssetMetadata::deserialize(data))
+    }
+
+    /// Add token information to the PSET, returns None if it wasn't present or Some with the old
+    /// data if already in the PSET
+    pub fn add_token_metadata(
+        &mut self,
+        token_id: AssetId,
+        token_meta: &TokenMetadata
+    ) -> Option<Result<TokenMetadata, encode::Error>> {
+        let key = prop_key(&token_id, PSBT_ELEMENTS_HWW_GLOBAL_REISSUANCE_TOKEN);
+        self.global
+            .proprietary
+            .insert(key, token_meta.serialize())
+            .map(|old| TokenMetadata::deserialize(&old))
+    }
+
+    /// Get token information from the PSET, returns None if there are no information regarding
+    /// the given `token_id` in the PSET
+    pub fn get_token_metadata(
+        &self,
+        token_id: AssetId
+    ) -> Option<Result<TokenMetadata, encode::Error>> {
+        let key = prop_key(&token_id, PSBT_ELEMENTS_HWW_GLOBAL_REISSUANCE_TOKEN);
+
+        self.global
+            .proprietary
+            .get(&key)
+            .map(|data| TokenMetadata::deserialize(data))
+    }
+}
+
+/// Asset metadata, the contract and the outpoint used to issue the asset
+#[derive(Debug, PartialEq, Eq)]
+pub struct AssetMetadata {
+    contract: String,
+    issuance_prevout: OutPoint,
+}
+
+/// Token metadata, the asset id and whether the issuance was blinded
+#[derive(Debug, PartialEq, Eq)]
+pub struct TokenMetadata {
+    asset_id: AssetId,
+    issuance_blinded: bool,
+}
+
+fn prop_key(asset_id: &AssetId, keytype: u8) -> ProprietaryKey {
+    let mut key = Vec::with_capacity(32);
+    asset_id
+        .consensus_encode(&mut key)
+        .expect("vec doesn't err"); // equivalent to asset_tag
+
+    ProprietaryKey {
+        prefix: PSET_HWW_PREFIX.to_vec(),
+        subtype: keytype,
+        key,
+    }
+}
+
+impl AssetMetadata {
+
+    /// Create a new [`AssetMetadata`]
+    pub fn new(contract: String, issuance_prevout: OutPoint) -> Self {
+        Self { contract, issuance_prevout }
+    }
+
+    /// Returns the contract as string containing a json
+    pub fn contract(&self) -> &str {
+        &self.contract
+    }
+
+    /// Returns the issuance prevout where the asset has been issued
+    pub fn issuance_prevout(&self) -> OutPoint {
+        self.issuance_prevout
+    }
+
+    /// Serialize this metadata as defined by ELIP0100
+    ///
+    /// `<compact size uint contractLen><contract><32-byte prevoutTxid><32-bit little endian uint prevoutIndex>`
+    pub fn serialize(&self) -> Vec<u8> {
+        let mut result = vec![];
+
+        encode::consensus_encode_with_size(self.contract.as_bytes(), &mut result)
+            .expect("vec doesn't err");
+
+        self.issuance_prevout
+            .consensus_encode(&mut result)
+            .expect("vec doesn't err");
+
+        result
+    }
+
+    /// Deserialize this metadata as defined by ELIP0100
+    pub fn deserialize(data: &[u8]) -> Result<AssetMetadata, encode::Error> {
+        let mut cursor = Cursor::new(data);
+        let str_bytes = Vec::<u8>::consensus_decode(&mut cursor)?;
+
+        let contract = String::from_utf8(str_bytes).map_err(|_| {
+            encode::Error::ParseFailed("utf8 conversion fail on the contract string")
+        })?;
+
+        let issuance_prevout = OutPoint::consensus_decode(&mut cursor)?;
+
+        Ok(AssetMetadata {
+            contract,
+            issuance_prevout,
+        })
+    }
+}
+
+impl TokenMetadata {
+
+    /// Create a new [`TokenMetadata`]
+    pub fn new(asset_id: AssetId, issuance_blinded: bool) -> Self {
+        Self { asset_id, issuance_blinded }
+    }
+
+    /// Returns the `asset_id`
+    pub fn asset_id(&self) -> &AssetId {
+        &self.asset_id
+    }
+
+    /// Returns whether the issuance was blinded or not
+    pub fn issuance_blinded(&self) -> bool {
+        self.issuance_blinded
+    }
+
+    /// Serialize this metadata as defined by ELIP0100
+    ///
+    /// `<1 byte boolean issuanceBlinded><32-byte asset tag>`
+    pub fn serialize(&self) -> Vec<u8> {
+        let mut result = vec![];
+
+        result.push(u8::from(self.issuance_blinded));
+
+        self.asset_id
+            .consensus_encode(&mut result)
+            .expect("vec doesn't err");
+
+        result
+    }
+
+    /// Deserialize this metadata as defined by ELIP0100
+    pub fn deserialize(data: &[u8]) -> Result<TokenMetadata, encode::Error> {
+        let mut cursor = Cursor::new(data);
+
+        let byte = u8::consensus_decode(&mut cursor)?;
+        if byte > 1 {
+            return Err(encode::Error::ParseFailed("invalid issuanceBlinded"));
+        }
+        let issuance_blinded = byte == 1;
+
+        let asset_id = AssetId::consensus_decode(&mut cursor)?;
+
+        Ok(TokenMetadata {
+            asset_id,
+            issuance_blinded
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use crate::encode::serialize;
+    use crate::{OutPoint, Txid};
+    use hex::DisplayHex as _;
+
+    use crate::{
+        encode::{serialize_hex, Encodable},
+        pset::{elip100::PSET_HWW_PREFIX, map::Map, PartiallySignedTransaction},
+        AssetId,
+    };
+
+    use super::{prop_key, AssetMetadata, PSBT_ELEMENTS_HWW_GLOBAL_ASSET_METADATA, TokenMetadata};
+
+    #[cfg(feature = "json-contract")]
+    const CONTRACT_HASH: &str = "3c7f0a53c2ff5b99590620d7f6604a7a3a7bfbaaa6aa61f7bfc7833ca03cde82";
+
+    const VALID_CONTRACT: &str = r#"{"entity":{"domain":"tether.to"},"issuer_pubkey":"0337cceec0beea0232ebe14cba0197a9fbd45fcf2ec946749de920e71434c2b904","name":"Tether USD","precision":8,"ticker":"USDt","version":0}"#;
+    const ISSUANCE_PREVOUT: &str =
+        "9596d259270ef5bac0020435e6d859aea633409483ba64e232b8ba04ce288668:0";
+    const ASSET_ID: &str = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
+
+    const ELIP0100_IDENTIFIER: &str = "fc08707365745f68777700";
+    const ELIP0100_ASSET_TAG: &str =
+        "48f835622f34e8fdc313c90d4a8659aa4afe993e32dcb03ae6ec9ccdc6fcbe18";
+    const ELIP0100_TOKEN_ID: &str =
+        "d739234098f77172cb22f0de8affd6826d6b9d23d97e04575764786a5b0056e1";
+    const ELIP0100_ISSUANCE_BLINDED: bool = true;
+
+    const ELIP0100_CONTRACT: &str = r#"{"entity":{"domain":"example.com"},"issuer_pubkey":"03455ee7cedc97b0ba435b80066fc92c963a34c600317981d135330c4ee43ac7a3","name":"Testcoin","precision":2,"ticker":"TEST","version":0}"#;
+    const ELIP0100_PREVOUT_TXID: &str =
+        "3514a07cf4812272c24a898c482f587a51126beef8c9b76a9e30bf41b0cbe53c";
+
+    const ELIP0100_PREVOUT_VOUT: u32 = 1;
+    const ELIP0100_ASSET_METADATA_RECORD_KEY: &str =
+        "fc08707365745f6877770018befcc6cd9cece63ab0dc323e99fe4aaa59864a0dc913c3fde8342f6235f848";
+    const ELIP0100_TOKEN_METADATA_RECORD_KEY: &str =
+        "fc08707365745f68777701e156005b6a78645757047ed9239d6b6d82d6ff8adef022cb7271f798402339d7";
+    const ELIP0100_ASSET_METADATA_RECORD_VALUE_WRONG: &str = "b47b22656e74697479223a7b22646f6d61696e223a226578616d706c652e636f6d227d2c226973737565725f7075626b6579223a22303334353565653763656463393762306261343335623830303636666339326339363361333463363030333137393831643133353333306334656534336163376133222c226e616d65223a2254657374636f696e222c22707265636973696f6e223a322c227469636b6572223a2254455354222c2276657273696f6e223a307d3514a07cf4812272c24a898c482f587a51126beef8c9b76a9e30bf41b0cbe53c01000000";
+
+    const ELIP0100_ASSET_METADATA_RECORD_VALUE: &str = "b47b22656e74697479223a7b22646f6d61696e223a226578616d706c652e636f6d227d2c226973737565725f7075626b6579223a22303334353565653763656463393762306261343335623830303636666339326339363361333463363030333137393831643133353333306334656534336163376133222c226e616d65223a2254657374636f696e222c22707265636973696f6e223a322c227469636b6572223a2254455354222c2276657273696f6e223a307d3ce5cbb041bf309e6ab7c9f8ee6b12517a582f488c894ac2722281f47ca0143501000000";
+    const ELIP0100_TOKEN_METADATA_RECORD_VALUE: &str = "0118befcc6cd9cece63ab0dc323e99fe4aaa59864a0dc913c3fde8342f6235f848";
+    fn mockup_asset_metadata() -> (AssetId, AssetMetadata) {
+        (
+            AssetId::from_str(ASSET_ID).unwrap(),
+            AssetMetadata {
+                contract: VALID_CONTRACT.to_string(),
+                issuance_prevout: ISSUANCE_PREVOUT.parse().unwrap(),
+            },
+        )
+    }
+
+    #[cfg(feature = "json-contract")]
+    #[test]
+    fn asset_metadata_roundtrip() {
+        let (_, asset_metadata) = mockup_asset_metadata();
+        let contract_hash = crate::ContractHash::from_str(CONTRACT_HASH).unwrap();
+        assert_eq!(
+            crate::ContractHash::from_json_contract(VALID_CONTRACT).unwrap(),
+            contract_hash
+        );
+        assert_eq!(
+            asset_metadata.serialize().to_lower_hex_string(),
+            "b47b22656e74697479223a7b22646f6d61696e223a227465746865722e746f227d2c226973737565725f7075626b6579223a22303333376363656563306265656130323332656265313463626130313937613966626434356663663265633934363734396465393230653731343334633262393034222c226e616d65223a2254657468657220555344222c22707265636973696f6e223a382c227469636b6572223a2255534474222c2276657273696f6e223a307d688628ce04bab832e264ba83944033a6ae59d8e6350402c0baf50e2759d2969500000000",
+        );
+
+        assert_eq!(
+            AssetMetadata::deserialize(&asset_metadata.serialize()).unwrap(),
+            asset_metadata
+        );
+    }
+
+    #[test]
+    fn prop_key_serialize() {
+        let asset_id = AssetId::from_str(ASSET_ID).unwrap();
+
+        let key = prop_key(&asset_id, PSBT_ELEMENTS_HWW_GLOBAL_ASSET_METADATA);
+        let mut vec = vec![];
+        key.consensus_encode(&mut vec).unwrap();
+
+        assert_eq!(
+            vec.to_lower_hex_string(),
+            format!("08{}00{}", PSET_HWW_PREFIX.to_lower_hex_string(), asset_id.into_tag())
+        );
+
+        assert!(vec.to_lower_hex_string().starts_with(&ELIP0100_IDENTIFIER[2..])); // cut prefix "fc: which is PSET_GLOBAL_PROPRIETARY serialized one level up
+    }
+
+    #[test]
+    fn set_get_asset_metadata() {
+        let mut pset = PartiallySignedTransaction::new_v2();
+        let (asset_id, asset_meta) = mockup_asset_metadata();
+
+        let old = pset.add_asset_metadata(asset_id, &asset_meta);
+        assert!(old.is_none());
+        let old = pset
+            .add_asset_metadata(asset_id, &asset_meta)
+            .unwrap()
+            .unwrap();
+        assert_eq!(old, asset_meta);
+
+        assert!(serialize_hex(&pset).contains(ELIP0100_IDENTIFIER));
+
+        let get = pset.get_asset_metadata(asset_id).unwrap().unwrap();
+        assert_eq!(get, asset_meta);
+    }
+
+    #[test]
+    fn elip0100_test_vector() {
+        let mut pset = PartiallySignedTransaction::new_v2();
+
+        let asset_id = AssetId::from_str(ELIP0100_ASSET_TAG).unwrap();
+        let txid = Txid::from_str(ELIP0100_PREVOUT_TXID).unwrap();
+
+        let asset_meta = AssetMetadata {
+            contract: ELIP0100_CONTRACT.to_string(),
+            issuance_prevout: OutPoint {
+                txid,
+                vout: ELIP0100_PREVOUT_VOUT,
+            },
+        };
+
+        pset.add_asset_metadata(asset_id, &asset_meta);
+
+        let expected_key = hex::hex!(ELIP0100_ASSET_METADATA_RECORD_KEY);
+
+        let values: Vec<Vec<u8>> = pset
+            .global
+            .get_pairs()
+            .unwrap()
+            .into_iter()
+            .filter(|p| serialize(&p.key)[1..] == expected_key[..]) // NOTE key serialization contains an initial varint with the length of the key which is not present in the test vector
+            .map(|p| p.value)
+            .collect();
+        assert_eq!(values.len(), 1);
+        assert_eq!(values[0].to_lower_hex_string(), ELIP0100_ASSET_METADATA_RECORD_VALUE);
+
+        let txid_hex_non_convention = txid.as_byte_array().to_lower_hex_string();
+        assert_eq!(
+            ELIP0100_ASSET_METADATA_RECORD_VALUE,
+            ELIP0100_ASSET_METADATA_RECORD_VALUE_WRONG
+                .replace(ELIP0100_PREVOUT_TXID, &txid_hex_non_convention),
+            "only change in the value is the txid"
+        );
+
+        let token_id = AssetId::from_str(ELIP0100_TOKEN_ID).unwrap();
+        let token_meta = TokenMetadata {
+            asset_id,
+            issuance_blinded: ELIP0100_ISSUANCE_BLINDED,
+        };
+
+        pset.add_token_metadata(token_id, &token_meta);
+
+        let expected_key = hex::hex!(ELIP0100_TOKEN_METADATA_RECORD_KEY);
+
+        let values: Vec<Vec<u8>> = pset
+            .global
+            .get_pairs()
+            .unwrap()
+            .into_iter()
+            .filter(|p| serialize(&p.key)[1..] == expected_key[..]) // NOTE key serialization contains an initial varint with the length of the key which is not present in the test vector
+            .map(|p| p.value)
+            .collect();
+        assert_eq!(values.len(), 1);
+        assert_eq!(values[0].to_lower_hex_string(), ELIP0100_TOKEN_METADATA_RECORD_VALUE);
+    }
+
+    #[cfg(feature = "json-contract")]
+    #[test]
+    fn elip0100_contract() {
+        let txid = Txid::from_str(ELIP0100_PREVOUT_TXID).unwrap();
+        let prevout = OutPoint {
+            txid,
+            vout: ELIP0100_PREVOUT_VOUT,
+        };
+
+        let contract_hash = crate::ContractHash::from_json_contract(ELIP0100_CONTRACT).unwrap();
+        let entropy = AssetId::generate_asset_entropy(prevout, contract_hash);
+        let asset_id = AssetId::from_entropy(entropy);
+
+        let expected = AssetId::from_str(ELIP0100_ASSET_TAG).unwrap();
+
+        assert_eq!(asset_id.to_string(), expected.to_string());
+    }
+}
diff --git a/src/pset/elip102.rs b/src/pset/elip102.rs
new file mode 100644
index 00000000..8504fc25
--- /dev/null
+++ b/src/pset/elip102.rs
@@ -0,0 +1,140 @@
+//!
+//! An implementation of ELIP0102 as defined in
+//! <https://github.com/ElementsProject/ELIPs/blob/main/elip-0102.mediawiki>
+//!
+//! ELIP0102 defines how to encode the extra data for `LiquiDEX` in a PSET.
+//!
+
+use crate::pset::{
+    confidential::AssetBlindingFactor,
+    encode,
+    raw::ProprietaryKey,
+    serialize::{Deserialize, Serialize},
+    Input, Output,
+};
+
+/// Input Asset Blinding Factor keytype as defined in ELIP0102
+pub const PSBT_ELEMENTS_LIQUIDEX_IN_ABF: u8 = 0x00u8;
+
+/// Output Asset Blinding Factor keytype as defined in ELIP0102
+pub const PSBT_ELEMENTS_LIQUIDEX_OUT_ABF: u8 = 0x00u8;
+
+/// Prefix for PSET `LiquiDEX` extension as defined in ELIP0102
+pub const PSET_LIQUIDEX_PREFIX: &[u8] = b"pset_liquidex";
+
+fn prop_key(keytype: u8) -> ProprietaryKey {
+    ProprietaryKey {
+        prefix: PSET_LIQUIDEX_PREFIX.to_vec(),
+        subtype: keytype,
+        key: vec![],
+    }
+}
+
+/// ELIP0102 `LiquiDEX` extensions
+impl Input {
+    /// Set Asset Blinding Factor
+    pub fn set_abf(&mut self, abf: AssetBlindingFactor) {
+        let key = prop_key(PSBT_ELEMENTS_LIQUIDEX_IN_ABF);
+        self.proprietary.insert(key, abf.serialize());
+    }
+
+    /// Get Asset Blinding Factor
+    pub fn get_abf(&self) -> Option<Result<AssetBlindingFactor, encode::Error>> {
+        let key = prop_key(PSBT_ELEMENTS_LIQUIDEX_IN_ABF);
+        self.proprietary
+            .get(&key)
+            .map(|data| AssetBlindingFactor::deserialize(data))
+    }
+}
+
+/// ELIP0102 `LiquiDEX` extensions
+impl Output {
+    /// Set Asset Blinding Factor
+    pub fn set_abf(&mut self, abf: AssetBlindingFactor) {
+        let key = prop_key(PSBT_ELEMENTS_LIQUIDEX_OUT_ABF);
+        self.proprietary.insert(key, abf.serialize());
+    }
+
+    /// Get Asset Blinding Factor
+    pub fn get_abf(&self) -> Option<Result<AssetBlindingFactor, encode::Error>> {
+        let key = prop_key(PSBT_ELEMENTS_LIQUIDEX_OUT_ABF);
+        self.proprietary
+            .get(&key)
+            .map(|data| AssetBlindingFactor::deserialize(data))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::AssetId;
+    use crate::encode::{serialize_hex, Encodable};
+    use hex::DisplayHex as _;
+
+    // b'\xfc\rpset_liquidex'
+    const ELIP0102_IDENTIFIER: &str = "fc0d707365745f6c69717569646578";
+
+    #[test]
+    fn prop_key_serialize() {
+        let key = prop_key(PSBT_ELEMENTS_LIQUIDEX_IN_ABF);
+        let mut vec = vec![];
+        key.consensus_encode(&mut vec).unwrap();
+
+        assert_eq!(
+            vec.to_lower_hex_string(),
+            format!("0d{}00", PSET_LIQUIDEX_PREFIX.to_lower_hex_string()),
+        );
+
+        assert!(vec.to_lower_hex_string().starts_with(&ELIP0102_IDENTIFIER[2..])); // cut proprietary prefix "fc"
+    }
+
+    #[test]
+    fn set_get_abf() {
+        // An ABF that's different if serialized in reverse or not
+        const ABF_HEX: &str = "3311111111111111111111111111111111111111111111111111111111111111";
+        let abf_bytes = hex::hex!(ABF_HEX);
+        let abf = AssetBlindingFactor::from_slice(&abf_bytes).unwrap();
+
+        let mut input = Input::default();
+        assert!(input.get_abf().is_none());
+        input.set_abf(abf);
+        assert_eq!(input.get_abf().unwrap().unwrap(), abf);
+        let input_hex = serialize_hex(&input);
+        assert!(input_hex.contains(ELIP0102_IDENTIFIER));
+        assert!(input_hex.contains(ABF_HEX));
+
+        let mut output = Output::default();
+        assert!(output.get_abf().is_none());
+        output.set_abf(abf);
+        assert_eq!(output.get_abf().unwrap().unwrap(), abf);
+        let output_hex = serialize_hex(&output);
+        assert!(output_hex.contains(ELIP0102_IDENTIFIER));
+        assert!(output_hex.contains(ABF_HEX));
+    }
+
+    #[test]
+    fn abf_roundtrip() {
+        use crate::pset::PartiallySignedTransaction;
+
+        // Set abf on an input and on an output
+        let abf = AssetBlindingFactor::from_slice(&[3; 32]).unwrap();
+        let mut pset = PartiallySignedTransaction::new_v2();
+        let mut input = Input::default();
+        input.set_abf(abf);
+        pset.add_input(input);
+        let mut output = Output {
+            amount: Some(1),
+            asset: Some(AssetId::from_byte_array([9; 32])),
+            ..Default::default()
+        };
+        output.set_abf(abf);
+        pset.add_output(output);
+
+        // Serialize and deserialize
+        let bytes = encode::serialize(&pset);
+        let pset_back = encode::deserialize::<PartiallySignedTransaction>(&bytes).unwrap();
+        // Check the abf
+        assert_eq!(pset_back.inputs()[0].get_abf().unwrap().unwrap(), abf);
+        assert_eq!(pset_back.outputs()[0].get_abf().unwrap().unwrap(), abf);
+    }
+}
diff --git a/src/pset/error.rs b/src/pset/error.rs
index 041284a1..0241f0ac 100644
--- a/src/pset/error.rs
+++ b/src/pset/error.rs
@@ -20,15 +20,18 @@ use crate::Txid;
 use super::raw;
 
 use crate::blind::ConfidentialTxOutError;
-use crate::hashes;
 use secp256k1_zkp;
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 /// Enum for marking pset hash error
 pub enum PsetHash {
+    /// Bad preimage for `RIPEMD160` hash.
     Ripemd,
+    /// Bad preimage for `SHA256` hash.
     Sha256,
+    /// Bad preimage for `RIPEMD160-SHA256` hash.
     Hash160,
+    /// Bad preimage for double-`SHA256` hash.
     Hash256,
 }
 /// Ways that a Partially Signed Transaction might fail.
@@ -48,12 +51,6 @@ pub enum Error {
     /// PSET has an input exclusively requiring a height-based locktime and also
     /// an input requiring a time-based locktime
     LocktimeConflict,
-    /// The scriptSigs for the unsigned transaction must be empty.
-    UnsignedTxHasScriptSigs,
-    /// The scriptWitnesses for the unsigned transaction must be empty.
-    UnsignedTxHasScriptWitnesses,
-    /// A PSET must have an unsigned transaction.
-    MustHaveUnsignedTx,
     /// Signals that there are no more key-value pairs in a key-value map.
     NoMorePairs,
     /// Attempting to merge with a PSET describing a different unsigned
@@ -64,11 +61,7 @@ pub enum Error {
         /// Actual
         actual: Txid,
     },
-    /// Unable to parse as a standard SigHash type.
-    NonStandardSigHashType(u32),
-    /// Parsing errors from bitcoin_hashes
-    HashParseError(hashes::Error),
-    /// The pre-image must hash to the correponding pset hash
+    /// The pre-image must hash to the corresponding pset hash
     InvalidPreimageHashPair {
         /// Hash-type
         hash_type: PsetHash,
@@ -83,7 +76,7 @@ pub enum Error {
     ConsensusEncoding,
     /// Too Large Pset
     TooLargePset,
-    /// Specified a feild in from psbt v0. Disallowed in psbtv2(pset)
+    /// Specified a field in from psbt v0. Disallowed in psbtv2(pset)
     ExpiredPsbtv0Field,
     /// Cannot change pset version
     IncorrectPsetVersion,
@@ -97,8 +90,6 @@ pub enum Error {
     MissingInputPrevTxId,
     /// Missing Input Prev Out
     MissingInputPrevVout,
-    /// Global scalar must be 32 bytes
-    SecpScalarSizeError(usize),
     /// Missing Output Value
     MissingOutputValue,
     /// Missing Output Asset
@@ -117,7 +108,7 @@ pub enum Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self {
             Error::InvalidKey(ref rkey) => write!(f, "invalid key: {}", rkey),
             Error::InvalidProprietaryKey => write!(
                 f,
@@ -129,22 +120,9 @@ impl fmt::Display for Error {
                 expected: ref e,
                 actual: ref a,
             } => write!(f, "different id: expected {}, actual {}", e, a),
-            Error::NonStandardSigHashType(ref sht) => {
-                write!(f, "non-standard sighash type: {}", sht)
-            }
             Error::InvalidMagic => f.write_str("invalid magic"),
             Error::InvalidSeparator => f.write_str("invalid separator"),
-            Error::UnsignedTxHasScriptSigs => {
-                f.write_str("the unsigned transaction has script sigs")
-            }
-            Error::UnsignedTxHasScriptWitnesses => {
-                f.write_str("the unsigned transaction has script witnesses")
-            }
-            Error::MustHaveUnsignedTx => {
-                f.write_str("partially signed transactions must have an unsigned transaction")
-            }
             Error::NoMorePairs => f.write_str("no more key-value pairs for this pset map"),
-            Error::HashParseError(e) => write!(f, "Hash Parse Error: {}", e),
             Error::InvalidPreimageHashPair {
                 ref preimage,
                 ref hash,
@@ -173,13 +151,6 @@ impl fmt::Display for Error {
             Error::MissingOutputCount => f.write_str("PSET missing output count"),
             Error::MissingInputPrevTxId => f.write_str("PSET input missing previous txid"),
             Error::MissingInputPrevVout => f.write_str("PSET input missing previous output index"),
-            Error::SecpScalarSizeError(actual) => {
-                write!(
-                    f,
-                    "PSET blinding scalars must be 32 bytes. Found {} bytes",
-                    actual
-                )
-            }
             Error::MissingOutputValue => f.write_str(
                 "PSET output missing value. Must have \
                 at least one of explicit/confidential value set",
@@ -213,13 +184,6 @@ impl fmt::Display for Error {
 
 impl error::Error for Error {}
 
-#[doc(hidden)]
-impl From<hashes::Error> for Error {
-    fn from(e: hashes::Error) -> Error {
-        Error::HashParseError(e)
-    }
-}
-
 impl From<encode::Error> for Error {
     fn from(err: encode::Error) -> Self {
         match err {
@@ -232,9 +196,9 @@ impl From<encode::Error> for Error {
 /// Ways that blinding a Partially Signed Transaction might fail.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum PsetBlindError {
-    /// Input TxOut len mismatch
+    /// Input `TxOut` len mismatch
     InputTxOutSecretLen,
-    /// Output TxOut len mismatch
+    /// Output `TxOut` len mismatch
     OutputTxOutSecretLen,
     /// Blinder index out of range
     BlinderIndexOutOfBounds(usize, usize),
@@ -250,6 +214,8 @@ pub enum PsetBlindError {
     ConfidentialTxOutError(usize, ConfidentialTxOutError),
     /// Blinding proof creation error
     BlindingProofsCreationError(usize, secp256k1_zkp::Error),
+    /// Blinding issuance unsupported
+    BlindingIssuanceUnsupported(usize),
 }
 
 impl fmt::Display for PsetBlindError {
@@ -291,6 +257,9 @@ impl fmt::Display for PsetBlindError {
                     e, i
                 )
             }
+            PsetBlindError::BlindingIssuanceUnsupported(i) => {
+                write!(f, "Blinding issuance is not supported, set blinded_issuance to 0 at input index {}", i)
+            }
         }
     }
 }
diff --git a/src/pset/macros.rs b/src/pset/macros.rs
index 82785eda..7928c746 100644
--- a/src/pset/macros.rs
+++ b/src/pset/macros.rs
@@ -16,7 +16,7 @@
 macro_rules! hex_pset {
     ($s:expr) => {
         $crate::encode::deserialize(
-            &<Vec<u8> as $crate::hashes::hex::FromHex>::from_hex($s).unwrap(),
+            hex_conservative::decode_to_vec($s).unwrap(),
         )
     };
 }
@@ -74,10 +74,10 @@ macro_rules! impl_psetmap_consensus_encoding {
     };
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 macro_rules! impl_pset_prop_insert_pair {
     ($slf:ident.$unkeyed_name:ident <= <$raw_key:ident: _>|<$raw_value:ident: $unkeyed_value_type:ty>) => {
-        if $crate::pset::raw::ProprietaryKey::<u8>::from_key($raw_key.clone())?.key.is_empty() {
+        if $crate::pset::raw::ProprietaryKey::<u8>::from_key(&$raw_key)?.key.is_empty() {
             if $slf.$unkeyed_name.is_none() {
                 let val: $unkeyed_value_type = $crate::pset::serialize::Deserialize::deserialize(&$raw_value)?;
                 $slf.$unkeyed_name = Some(val)
@@ -102,7 +102,7 @@ macro_rules! impl_pset_prop_insert_pair {
     };
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 macro_rules! impl_pset_insert_pair {
     ($slf:ident.$unkeyed_name:ident <= <$raw_key:ident: _>|<$raw_value:ident: $unkeyed_value_type:ty>) => {
         if $raw_key.key.is_empty() {
@@ -144,7 +144,7 @@ macro_rules! impl_pset_insert_pair {
     };
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 macro_rules! impl_pset_get_pair {
     ($rv:ident.push($slf:ident.$unkeyed_name:ident as <$unkeyed_typeval:expr, _>)) => {
         if let Some(ref $unkeyed_name) = $slf.$unkeyed_name {
@@ -211,8 +211,7 @@ macro_rules! impl_pset_hash_deserialize {
     ($hash_type:ty) => {
         impl $crate::pset::serialize::Deserialize for $hash_type {
             fn deserialize(bytes: &[u8]) -> Result<Self, $crate::encode::Error> {
-                <$hash_type>::from_slice(&bytes[..])
-                    .map_err(|e| $crate::pset::Error::from(e).into())
+                $crate::encode::deserialize(bytes).map(Self::from_byte_array)
             }
         }
     };
@@ -222,7 +221,7 @@ macro_rules! impl_pset_hash_serialize {
     ($hash_type:ty) => {
         impl $crate::pset::serialize::Serialize for $hash_type {
             fn serialize(&self) -> Vec<u8> {
-                self.into_inner().to_vec()
+                self.to_byte_array().to_vec()
             }
         }
     };
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
index cdf4848e..4ed267e3 100644
--- a/src/pset/map/global.rs
+++ b/src/pset/map/global.rs
@@ -20,34 +20,34 @@ use std::{
     io::{self, Cursor, Read},
 };
 
-use crate::encode;
+use crate::encode::{self, VarInt};
 use crate::encode::Decodable;
 use crate::endian::u32_to_array_le;
 use crate::pset::{self, map::Map, raw, Error};
-use crate::{PackedLockTime, VarInt};
-use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint, KeySource};
+use crate::LockTime;
+use bitcoin::bip32::{ChildNumber, DerivationPath, Xpub, Fingerprint, KeySource};
 use secp256k1_zkp::Tweak;
 
 // (Not used in pset) Type: Unsigned Transaction PSET_GLOBAL_UNSIGNED_TX = 0x00
 const PSET_GLOBAL_UNSIGNED_TX: u8 = 0x00;
 //
-/// Type: Extended Public Key PSET_GLOBAL_XPUB = 0x01
+/// Type: Extended Public Key `PSET_GLOBAL_XPUB` = 0x01
 const PSET_GLOBAL_XPUB: u8 = 0x01;
 
-/// Type: Tx Version PSET_GLOBAL_TX_VERSION = 0x02
+/// Type: Tx Version `PSET_GLOBAL_TX_VERSION` = 0x02
 const PSET_GLOBAL_TX_VERSION: u8 = 0x02;
-/// Type: Fallback Locktime PSET_GLOBAL_FALLBACK_LOCKTIME = 0x03
+/// Type: Fallback Locktime `PSET_GLOBAL_FALLBACK_LOCKTIME` = 0x03
 const PSET_GLOBAL_FALLBACK_LOCKTIME: u8 = 0x03;
-/// Type: Tx Input Count PSET_GLOBAL_INPUT_COUNT = 0x04
+/// Type: Tx Input Count `PSET_GLOBAL_INPUT_COUNT` = 0x04
 const PSET_GLOBAL_INPUT_COUNT: u8 = 0x04;
-/// Type: Tx Output Count PSET_GLOBAL_OUTPUT_COUNT = 0x05
+/// Type: Tx Output Count `PSET_GLOBAL_OUTPUT_COUNT` = 0x05
 const PSET_GLOBAL_OUTPUT_COUNT: u8 = 0x05;
-/// Type: Transaction Modifiable Flags PSET_GLOBAL_TX_MODIFIABLE = 0x06
+/// Type: Transaction Modifiable Flags `PSET_GLOBAL_TX_MODIFIABLE` = 0x06
 const PSET_GLOBAL_TX_MODIFIABLE: u8 = 0x06;
 
-/// Type: Version Number PSET_GLOBAL_VERSION = 0xFB
+/// Type: Version Number `PSET_GLOBAL_VERSION` = 0xFB
 const PSET_GLOBAL_VERSION: u8 = 0xFB;
-/// Type: Proprietary Use Type PSET_GLOBAL_PROPRIETARY = 0xFC
+/// Type: Proprietary Use Type `PSET_GLOBAL_PROPRIETARY` = 0xFC
 const PSET_GLOBAL_PROPRIETARY: u8 = 0xFC;
 
 /// Proprietary fields in elements
@@ -58,13 +58,12 @@ const PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE: u8 = 0x01;
 
 /// Global transaction data
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct TxData {
     /// Transaction version. Must be 2.
     pub version: u32,
     /// Locktime to use if no inputs specify a minimum locktime to use.
     /// May be omitted in which case it is interpreted as 0.
-    pub fallback_locktime: Option<crate::PackedLockTime>,
+    pub fallback_locktime: Option<LockTime>,
     /// Number of inputs in the transaction
     /// Not public. Users should not be able to mutate this directly
     /// This will be automatically whenever pset inputs are added
@@ -93,32 +92,22 @@ impl Default for TxData {
 
 /// A key-value map for global data.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Global {
     /// Global transaction data
-    #[cfg_attr(feature = "serde", serde(flatten))]
     pub tx_data: TxData,
     /// The version number of this PSET. Must be present.
     pub version: u32,
     /// A global map from extended public keys to the used key fingerprint and
     /// derivation path as defined by BIP 32
-    pub xpub: BTreeMap<ExtendedPubKey, KeySource>,
+    pub xpub: BTreeMap<Xpub, KeySource>,
     // Global proprietary key-value pairs.
     /// Scalars used for blinding
     pub scalars: Vec<Tweak>,
     /// Elements tx modifiable flag
     pub elements_tx_modifiable_flag: Option<u8>,
     /// Other Proprietary fields
-    #[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>>,
 }
 
@@ -165,17 +154,16 @@ impl Map for Global {
             | PSET_GLOBAL_TX_MODIFIABLE
             | PSET_GLOBAL_TX_VERSION => return Err(Error::DuplicateKey(raw_key).into()),
             PSET_GLOBAL_PROPRIETARY => {
-                let prop_key = raw::ProprietaryKey::from_key(raw_key.clone())?;
+                let prop_key = raw::ProprietaryKey::from_key(&raw_key)?;
                 if prop_key.is_pset_key() && prop_key.subtype == PSBT_ELEMENTS_GLOBAL_SCALAR {
                     if raw_value.is_empty() && prop_key.key.len() == 32 {
                         let scalar = Tweak::from_slice(&prop_key.key)?;
-                        if !self.scalars.contains(&scalar) {
-                            self.scalars.push(scalar);
-                        } else {
+                        if self.scalars.contains(&scalar) {
                             return Err(Error::DuplicateKey(raw_key).into());
                         }
+                        self.scalars.push(scalar);
                     } else {
-                        return Err(Error::InvalidKey(raw_key.into()))?;
+                        return Err(Error::InvalidKey(raw_key).into());
                     }
                 } else if prop_key.is_pset_key()
                     && prop_key.subtype == PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE
@@ -183,7 +171,7 @@ impl Map for Global {
                     if prop_key.key.is_empty() && raw_value.len() == 1 {
                         self.elements_tx_modifiable_flag = Some(raw_value[0]);
                     } else {
-                        return Err(Error::InvalidKey(raw_key.into()))?;
+                        return Err(Error::InvalidKey(raw_key).into());
                     }
                 } else {
                     match self.proprietary.entry(prop_key) {
@@ -206,7 +194,7 @@ impl Map for Global {
     }
 
     fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
+        let mut rv: Vec<raw::Pair> = Vec::default();
 
         let TxData {
             version,
@@ -269,21 +257,21 @@ impl Map for Global {
             rv.push(raw::Pair {
                 key: key.to_key(),
                 value: vec![], // This is a bug in elements core c++, parses this value as vec![0]
-            })
+            });
         }
 
         impl_pset_get_pair! {
             rv.push_prop(self.elements_tx_modifiable_flag as <PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE, _>)
         }
 
-        for (key, value) in self.proprietary.iter() {
+        for (key, value) in &self.proprietary {
             rv.push(raw::Pair {
                 key: key.to_key(),
                 value: value.clone(),
             });
         }
 
-        for (key, value) in self.unknown.iter() {
+        for (key, value) in &self.unknown {
             rv.push(raw::Pair {
                 key: key.clone(),
                 value: value.clone(),
@@ -295,6 +283,7 @@ impl Map for Global {
 
     // Keep in mind that according to BIP 174 this function must be commutative, i.e.
     // A.merge(B) == B.merge(A)
+    #[allow(clippy::if_same_then_else)] // we have several `else if` branches which are just `continue`
     fn merge(&mut self, other: Self) -> Result<(), pset::Error> {
         // BIP 174: The Combiner must remove any duplicate key-value pairs, in accordance with
         //          the specification. It can pick arbitrarily when conflicts occur.
@@ -341,7 +330,7 @@ impl Map for Global {
                         continue;
                     }
                     return Err(pset::Error::MergeConflict(
-                        format!("global xpub {} has inconsistent key sources", xpub).to_owned(),
+                        format!("global xpub {} has inconsistent key sources", xpub)
                     ));
                 }
             }
@@ -367,16 +356,16 @@ impl_psetmap_consensus_encoding!(Global);
 impl Decodable for Global {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
         let mut version: Option<u32> = None;
-        let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = Default::default();
-        let mut xpub_map: BTreeMap<ExtendedPubKey, (Fingerprint, DerivationPath)> =
-            Default::default();
+        let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = BTreeMap::new();
+        let mut xpub_map: BTreeMap<Xpub, (Fingerprint, DerivationPath)> =
+            BTreeMap::new();
         let mut proprietary = BTreeMap::new();
         let mut scalars = Vec::new();
 
         let mut tx_version: Option<u32> = None;
         let mut input_count: Option<VarInt> = None;
         let mut output_count: Option<VarInt> = None;
-        let mut fallback_locktime: Option<PackedLockTime> = None;
+        let mut fallback_locktime: Option<LockTime> = None;
         let mut tx_modifiable: Option<u8> = None;
         let mut elements_tx_modifiable_flag: Option<u8> = None;
 
@@ -395,7 +384,7 @@ impl Decodable for Global {
                         }
                         PSET_GLOBAL_FALLBACK_LOCKTIME => {
                             impl_pset_insert_pair! {
-                                fallback_locktime <= <raw_key: _>|<raw_value: PackedLockTime>
+                                fallback_locktime <= <raw_key: _>|<raw_value: LockTime>
                             }
                         }
                         PSET_GLOBAL_INPUT_COUNT => {
@@ -414,41 +403,41 @@ impl Decodable for Global {
                             }
                         }
                         PSET_GLOBAL_XPUB => {
-                            if !raw_key.key.is_empty() {
-                                let xpub = ExtendedPubKey::decode(&raw_key.key)
-                                    .map_err(|_| encode::Error::ParseFailed(
-                                        "Can't deserialize ExtendedPublicKey from global XPUB key data"
-                                    ))?;
-
-                                if raw_value.is_empty() || raw_value.len() % 4 != 0 {
-                                    return Err(encode::Error::ParseFailed(
-                                        "Incorrect length of global xpub derivation data",
-                                    ));
-                                }
-
-                                let child_count = raw_value.len() / 4 - 1;
-                                let mut decoder = Cursor::new(raw_value);
-                                let mut fingerprint = [0u8; 4];
-                                decoder.read_exact(&mut fingerprint[..])?;
-                                let mut path = Vec::<ChildNumber>::with_capacity(child_count);
-                                while let Ok(index) = u32::consensus_decode(&mut decoder) {
-                                    path.push(ChildNumber::from(index))
-                                }
-                                let derivation = DerivationPath::from(path);
-                                // Keys, according to BIP-174, must be unique
-                                if xpub_map
-                                    .insert(xpub, (Fingerprint::from(&fingerprint[..]), derivation))
-                                    .is_some()
-                                {
-                                    return Err(encode::Error::ParseFailed(
-                                        "Repeated global xpub key",
-                                    ));
-                                }
-                            } else {
+                            if raw_key.key.is_empty() {
                                 return Err(encode::Error::ParseFailed(
                                     "Xpub global key must contain serialized Xpub data",
                                 ));
                             }
+
+                            let xpub = Xpub::decode(&raw_key.key)
+                                .map_err(|_| encode::Error::ParseFailed(
+                                    "Can't deserialize Xpub from global XPUB key data"
+                                ))?;
+
+                            if raw_value.is_empty() || raw_value.len() % 4 != 0 {
+                                return Err(encode::Error::ParseFailed(
+                                    "Incorrect length of global xpub derivation data",
+                                ));
+                            }
+
+                            let child_count = raw_value.len() / 4 - 1;
+                            let mut decoder = Cursor::new(raw_value);
+                            let mut fingerprint = [0u8; 4];
+                            decoder.read_exact(&mut fingerprint[..])?;
+                            let mut path = Vec::<ChildNumber>::with_capacity(child_count);
+                            while let Ok(index) = u32::consensus_decode(&mut decoder) {
+                                path.push(ChildNumber::from(index));
+                            }
+                            let derivation = DerivationPath::from(path);
+                            // Keys, according to BIP-174, must be unique
+                            if xpub_map
+                                .insert(xpub, (Fingerprint::from(fingerprint), derivation))
+                                .is_some()
+                            {
+                                return Err(encode::Error::ParseFailed(
+                                    "Repeated global xpub key",
+                                ));
+                            }
                         }
                         PSET_GLOBAL_VERSION => {
                             impl_pset_insert_pair! {
@@ -456,19 +445,18 @@ impl Decodable for Global {
                             }
                         }
                         PSET_GLOBAL_PROPRIETARY => {
-                            let prop_key = raw::ProprietaryKey::from_key(raw_key.clone())?;
+                            let prop_key = raw::ProprietaryKey::from_key(&raw_key)?;
                             if prop_key.is_pset_key()
                                 && prop_key.subtype == PSBT_ELEMENTS_GLOBAL_SCALAR
                             {
                                 if raw_value.is_empty() && prop_key.key.len() == 32 {
                                     let scalar = Tweak::from_slice(&prop_key.key)?;
-                                    if !scalars.contains(&scalar) {
-                                        scalars.push(scalar);
-                                    } else {
+                                    if scalars.contains(&scalar) {
                                         return Err(Error::DuplicateKey(raw_key).into());
                                     }
+                                    scalars.push(scalar);
                                 } else {
-                                    return Err(Error::InvalidKey(raw_key.into()))?;
+                                    return Err(Error::InvalidKey(raw_key).into());
                                 }
                             } else if prop_key.is_pset_key()
                                 && prop_key.subtype == PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE
@@ -476,7 +464,7 @@ impl Decodable for Global {
                                 if prop_key.key.is_empty() && raw_value.len() == 1 {
                                     elements_tx_modifiable_flag = Some(raw_value[0]);
                                 } else {
-                                    return Err(Error::InvalidKey(raw_key.into()))?;
+                                    return Err(Error::InvalidKey(raw_key).into());
                                 }
                             } else {
                                 match proprietary.entry(prop_key) {
@@ -507,7 +495,7 @@ impl Decodable for Global {
         // Mandatory fields
         let version = version.ok_or(Error::IncorrectPsetVersion)?;
         if version != 2 {
-            return Err(Error::IncorrectPsetVersion)?;
+            return Err(Error::IncorrectPsetVersion.into());
         }
         let tx_version = tx_version.ok_or(Error::MissingTxVersion)?;
         let input_count = input_count.ok_or(Error::MissingInputCount)?.0 as usize;
@@ -521,12 +509,12 @@ impl Decodable for Global {
                 output_count,
                 tx_modifiable,
             },
-            version: version,
+            version,
             xpub: xpub_map,
-            proprietary: proprietary,
+            proprietary,
             unknown: unknowns,
-            scalars: scalars,
-            elements_tx_modifiable_flag: elements_tx_modifiable_flag,
+            scalars,
+            elements_tx_modifiable_flag,
         };
         Ok(global)
     }
diff --git a/src/pset/map/input.rs b/src/pset/map/input.rs
index 73227ca4..ce8c56dc 100644
--- a/src/pset/map/input.rs
+++ b/src/pset/map/input.rs
@@ -20,83 +20,83 @@ use std::{
     str::FromStr,
 };
 
-use crate::taproot::{ControlBlock, LeafVersion, TapBranchHash, TapLeafHash};
-use crate::{schnorr, AssetId, ContractHash};
+use crate::taproot::{ControlBlock, LeafVersion, TapNodeHash, TapLeafHash};
+use crate::{schnorr, AssetId};
 
 use crate::{confidential, locktime};
 use crate::encode::{self, Decodable};
-use crate::hashes::{self, hash160, ripemd160, sha256, sha256d};
+use crate::hashes::{self, hash160, ripemd160, sha256, sha256d, Hash};
+use crate::issuance::AssetEntropy;
 use crate::pset::map::Map;
 use crate::pset::raw;
 use crate::pset::serialize;
 use crate::pset::{self, error, Error};
-use crate::{transaction::SighashTypeParseError, SchnorrSigHashType};
-use crate::{AssetIssuance, BlockHash, EcdsaSigHashType, Script, Transaction, TxIn, TxOut, Txid};
-use bitcoin::util::bip32::KeySource;
-use bitcoin::{self, PublicKey};
-use hashes::Hash;
-use secp256k1_zkp::{self, RangeProof, Tweak, ZERO_TWEAK};
+use crate::{transaction::SighashTypeParseError, SchnorrSighashType};
+use crate::{AssetBlindingNonce, AssetIssuance, BlockHash, EcdsaSighashType, PeginWitness, RangeProof, Script, Transaction, TxIn, TxOut, Txid, SurjectionProof};
+use bitcoin::bip32::KeySource;
+use bitcoin::{PublicKey, key::XOnlyPublicKey};
+use secp256k1_zkp;
 
 use crate::{OutPoint, Sequence};
 
-/// Type: Non-Witness UTXO PSET_IN_NON_WITNESS_UTXO = 0x00
+/// Type: Non-Witness UTXO `PSET_IN_NON_WITNESS_UTXO` = 0x00
 const PSET_IN_NON_WITNESS_UTXO: u8 = 0x00;
-/// Type: Witness UTXO PSET_IN_WITNESS_UTXO = 0x01
+/// Type: Witness UTXO `PSET_IN_WITNESS_UTXO` = 0x01
 const PSET_IN_WITNESS_UTXO: u8 = 0x01;
-/// Type: Partial Signature PSET_IN_PARTIAL_SIG = 0x02
+/// Type: Partial Signature `PSET_IN_PARTIAL_SIG` = 0x02
 const PSET_IN_PARTIAL_SIG: u8 = 0x02;
-/// Type: Sighash Type PSET_IN_SIGHASH_TYPE = 0x03
+/// Type: Sighash Type `PSET_IN_SIGHASH_TYPE` = 0x03
 const PSET_IN_SIGHASH_TYPE: u8 = 0x03;
-/// Type: Redeem Script PSET_IN_REDEEM_SCRIPT = 0x04
+/// Type: Redeem Script `PSET_IN_REDEEM_SCRIPT` = 0x04
 const PSET_IN_REDEEM_SCRIPT: u8 = 0x04;
-/// Type: Witness Script PSET_IN_WITNESS_SCRIPT = 0x05
+/// Type: Witness Script `PSET_IN_WITNESS_SCRIPT` = 0x05
 const PSET_IN_WITNESS_SCRIPT: u8 = 0x05;
-/// Type: BIP 32 Derivation Path PSET_IN_BIP32_DERIVATION = 0x06
+/// Type: BIP 32 Derivation Path `PSET_IN_BIP32_DERIVATION` = 0x06
 const PSET_IN_BIP32_DERIVATION: u8 = 0x06;
-/// Type: Finalized scriptSig PSET_IN_FINAL_SCRIPTSIG = 0x07
+/// Type: Finalized scriptSig `PSET_IN_FINAL_SCRIPTSIG` = 0x07
 const PSET_IN_FINAL_SCRIPTSIG: u8 = 0x07;
-/// Type: Finalized scriptWitness PSET_IN_FINAL_SCRIPTWITNESS = 0x08
+/// Type: Finalized scriptWitness `PSET_IN_FINAL_SCRIPTWITNESS` = 0x08
 const PSET_IN_FINAL_SCRIPTWITNESS: u8 = 0x08;
-/// Type: RIPEMD160 preimage PSET_IN_RIPEMD160 = 0x0a
+/// Type: RIPEMD160 preimage `PSET_IN_RIPEMD160` = 0x0a
 const PSET_IN_RIPEMD160: u8 = 0x0a;
-/// Type: SHA256 preimage PSET_IN_SHA256 = 0x0b
+/// Type: SHA256 preimage `PSET_IN_SHA256` = 0x0b
 const PSET_IN_SHA256: u8 = 0x0b;
-/// Type: HASH160 preimage PSET_IN_HASH160 = 0x0c
+/// Type: HASH160 preimage `PSET_IN_HASH160` = 0x0c
 const PSET_IN_HASH160: u8 = 0x0c;
-/// Type: HASH256 preimage PSET_IN_HASH256 = 0x0d
+/// Type: HASH256 preimage `PSET_IN_HASH256` = 0x0d
 const PSET_IN_HASH256: u8 = 0x0d;
-/// Type: (Mandatory) Previous TXID PSET_IN_PREVIOUS_TXID = 0x0e
+/// Type: (Mandatory) Previous TXID `PSET_IN_PREVIOUS_TXID` = 0x0e
 const PSET_IN_PREVIOUS_TXID: u8 = 0x0e;
-/// Type: (Mandatory) Spent Output Index PSET_IN_OUTPUT_INDEX = 0x0f
+/// Type: (Mandatory) Spent Output Index `PSET_IN_OUTPUT_INDEX` = 0x0f
 const PSET_IN_OUTPUT_INDEX: u8 = 0x0f;
-/// Type: Sequence Number PSET_IN_SEQUENCE = 0x10
+/// Type: Sequence Number `PSET_IN_SEQUENCE` = 0x10
 const PSET_IN_SEQUENCE: u8 = 0x10;
-/// Type: Required Time-based Locktime PSET_IN_REQUIRED_TIME_LOCKTIME = 0x11
+/// Type: Required Time-based Locktime `PSET_IN_REQUIRED_TIME_LOCKTIME` = 0x11
 const PSET_IN_REQUIRED_TIME_LOCKTIME: u8 = 0x11;
-/// Type: Required Height-based Locktime PSET_IN_REQUIRED_HEIGHT_LOCKTIME = 0x12
+/// Type: Required Height-based Locktime `PSET_IN_REQUIRED_HEIGHT_LOCKTIME` = 0x12
 const PSET_IN_REQUIRED_HEIGHT_LOCKTIME: u8 = 0x12;
-/// Type: Schnorr Signature in Key Spend PSBT_IN_TAP_KEY_SIG = 0x13
+/// Type: Schnorr Signature in Key Spend `PSBT_IN_TAP_KEY_SIG` = 0x13
 const PSBT_IN_TAP_KEY_SIG: u8 = 0x13;
-/// Type: Schnorr Signature in Script Spend PSBT_IN_TAP_SCRIPT_SIG = 0x14
+/// Type: Schnorr Signature in Script Spend `PSBT_IN_TAP_SCRIPT_SIG` = 0x14
 const PSBT_IN_TAP_SCRIPT_SIG: u8 = 0x14;
-/// Type: Taproot Leaf Script PSBT_IN_TAP_LEAF_SCRIPT = 0x14
+/// Type: Taproot Leaf Script `PSBT_IN_TAP_LEAF_SCRIPT` = 0x14
 const PSBT_IN_TAP_LEAF_SCRIPT: u8 = 0x15;
-/// Type: Taproot Key BIP 32 Derivation Path PSBT_IN_TAP_BIP32_DERIVATION = 0x16
+/// Type: Taproot Key BIP 32 Derivation Path `PSBT_IN_TAP_BIP32_DERIVATION` = 0x16
 const PSBT_IN_TAP_BIP32_DERIVATION: u8 = 0x16;
-/// Type: Taproot Internal Key PSBT_IN_TAP_INTERNAL_KEY = 0x17
+/// Type: Taproot Internal Key `PSBT_IN_TAP_INTERNAL_KEY` = 0x17
 const PSBT_IN_TAP_INTERNAL_KEY: u8 = 0x17;
-/// Type: Taproot Merkle Root PSBT_IN_TAP_MERKLE_ROOT = 0x18
+/// Type: Taproot Merkle Root `PSBT_IN_TAP_MERKLE_ROOT` = 0x18
 const PSBT_IN_TAP_MERKLE_ROOT: u8 = 0x18;
-/// Type: Proprietary Use Type PSET_IN_PROPRIETARY = 0xFC
+/// Type: Proprietary Use Type `PSET_IN_PROPRIETARY` = 0xFC
 const PSET_IN_PROPRIETARY: u8 = 0xFC;
 
 // Elements Proprietary types:
 /// Issuance Value: The explicit little endian 64-bit integer
 /// for the value of this issuance. This is mutually exclusive with
-/// PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT
+/// `PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT`
 const PSBT_ELEMENTS_IN_ISSUANCE_VALUE: u8 = 0x00;
 /// Issuance Value Commitment: The 33 byte Value Commitment.
-/// This is mutually exclusive with PSBT_IN_ISSUANCE_VALUE.
+/// This is mutually exclusive with `PSBT_IN_ISSUANCE_VALUE`.
 const PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT: u8 = 0x01;
 /// Issuance Value Rangeproof: The rangeproof
 const PSBT_ELEMENTS_IN_ISSUANCE_VALUE_RANGEPROOF: u8 = 0x02;
@@ -118,11 +118,11 @@ const PSBT_ELEMENTS_IN_PEG_IN_VALUE: u8 = 0x08;
 const PSBT_ELEMENTS_IN_PEG_IN_WITNESS: u8 = 0x09;
 /// Issuance Inflation Keys Amount: The value for the inflation keys output to
 /// set in this issuance. This is mutually exclusive with
-/// PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT.
+/// `PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT`.
 const PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS: u8 = 0x0a;
 /// Issuance Inflation Keys Amount Commitment: The 33 byte commitment to the
 /// inflation keys output value in this issuance. This is mutually exclusive
-/// with PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS
+/// with `PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS`
 const PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT: u8 = 0x0b;
 /// Issuance Blinding Nonce: The 32 byte asset blinding nonce. For new assets,
 /// must be 0. For reissuances, this is a revelation of the blinding factor for
@@ -140,34 +140,58 @@ const PSBT_ELEMENTS_IN_ISSUANCE_ASSET_ENTROPY: u8 = 0x0d;
 /// the blinding factors for the UTXOs that they are involved in.
 const PSBT_ELEMENTS_IN_UTXO_RANGEPROOF: u8 = 0x0e;
 /// An explicit value rangeproof that proves that the value commitment in
-/// PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT matches the explicit value in
-/// PSBT_ELEMENTS_IN_ISSUANCE_VALUE. If provided, PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT
+/// `PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT` matches the explicit value in
+/// `PSBT_ELEMENTS_IN_ISSUANCE_VALUE`. If provided, `PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT`
 /// must be provided too.
 const PSBT_ELEMENTS_IN_ISSUANCE_BLIND_VALUE_PROOF: u8 = 0x0f;
 /// An explicit value rangeproof that proves that the value commitment in
-/// PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT matches the explicit value
-/// in PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS. If provided,
-/// PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT must be provided too.
+/// `PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT` matches the explicit value
+/// in `PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS`. If provided,
+/// `PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT` must be provided too.
 const PSBT_ELEMENTS_IN_ISSUANCE_BLIND_INFLATION_KEYS_PROOF: u8 = 0x10;
+/// The explicit value for the input being spent. If provided,
+/// `PSBT_ELEMENTS_IN_VALUE_PROOF` must be provided too.
+const PSBT_ELEMENTS_IN_EXPLICIT_VALUE: u8 = 0x11;
+/// An explicit value rangeproof that proves that the value commitment in this
+/// input's UTXO matches the explicit value in `PSBT_ELEMENTS_IN_EXPLICIT_VALUE`.
+/// If provided, `PSBT_ELEMENTS_IN_EXPLICIT_VALUE` must be provided too.
+const PSBT_ELEMENTS_IN_VALUE_PROOF: u8 = 0x12;
+/// The explicit asset for the input being spent. If provided,
+/// `PSBT_ELEMENTS_IN_ASSET_PROOF` must be provided too.
+const PSBT_ELEMENTS_IN_EXPLICIT_ASSET: u8 = 0x13;
+/// An asset surjection proof with this input's asset as the only asset in the
+/// input set in order to prove that the asset commitment in the UTXO matches
+/// the explicit asset in `PSBT_ELEMENTS_IN_EXPLICIT_ASSET`. If provided,
+/// `PSBT_ELEMENTS_IN_EXPLICIT_ASSET` must be provided too.
+const PSBT_ELEMENTS_IN_ASSET_PROOF: u8 = 0x14;
+/// A boolean flag. 0x00 indicates the issuance should not be blinded,
+/// 0x01 indicates it should be. If not specified, assumed to be 0x01.
+/// Note that this does not indicate actual blinding status,
+/// but rather the expected blinding status prior to signing.
+const PSBT_ELEMENTS_IN_BLINDED_ISSUANCE: u8 = 0x15;
+
+/// Bit of [`Input::previous_output_index`] indicating that the input is a pegin.
+const OUTPOINT_PEGIN_FLAG: u32 = 1 << 30;
+/// Bit of [`Input::previous_output_index`] indicating that the input has an issuance.
+const OUTPOINT_ISSUANCE_FLAG: u32 = 1 << 31;
+/// The previous output index of a coinbase input, which is all 1's and therefore
+/// carries no pegin/issuance flags.
+const OUTPOINT_COINBASE_INDEX: u32 = 0xffff_ffff;
+
 /// A key-value map for an input of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
-    /// [std::option::Option::Some] for inputs which spend non-segwit outputs or
+    /// [`std::option::Option::Some`] for inputs which spend non-segwit outputs or
     /// if it is unknown whether an input spends a segwit output.
     pub non_witness_utxo: Option<Transaction>,
     /// The transaction output this input spends from. Should only be
-    /// [std::option::Option::Some] for inputs which spend segwit outputs,
+    /// [`std::option::Option::Some`] for inputs which spend segwit outputs,
     /// including P2SH embedded ones.
     pub witness_utxo: Option<TxOut>,
     /// A map from public keys to their corresponding signature as would be
     /// pushed to the stack from a scriptSig or witness.
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub partial_sigs: BTreeMap<PublicKey, Vec<u8>>,
     /// The sighash type to be used for this input. Signatures for this input
     /// must use the sighash type.
@@ -178,38 +202,21 @@ pub struct Input {
     pub witness_script: Option<Script>,
     /// 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<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<Script>,
     /// The finalized, fully-constructed scriptWitness with signatures and any
     /// other scripts necessary for this input to pass validation.
-    pub final_script_witness: Option<Vec<Vec<u8>>>,
+    pub final_script_witness: Option<crate::Witness>,
     /// TODO: Proof of reserves commitment
     /// 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>>,
     /// HSAH160 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
     /// HAS256 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash256_preimages: BTreeMap<sha256d::Hash, Vec<u8>>,
     /// (PSET) Prevout TXID of the input
     pub previous_txid: Txid,
@@ -223,29 +230,26 @@ pub struct Input {
     pub required_height_locktime: Option<locktime::Height>,
     /// Serialized schnorr signature with sighash type for key spend
     pub tap_key_sig: Option<schnorr::SchnorrSig>,
-    /// Map of <xonlypubkey>|<leafhash> with signature
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
-    pub tap_script_sigs: BTreeMap<(bitcoin::XOnlyPublicKey, TapLeafHash), schnorr::SchnorrSig>,
+    /// Map of `<xonlypubkey>|<leafhash>` with signature
+    pub tap_script_sigs: BTreeMap<(XOnlyPublicKey, TapLeafHash), schnorr::SchnorrSig>,
     /// 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, (Script, 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<bitcoin::XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
+    pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
     /// Taproot Internal key
-    pub tap_internal_key: Option<bitcoin::XOnlyPublicKey>,
+    pub tap_internal_key: Option<XOnlyPublicKey>,
     /// Taproot Merkle root
-    pub tap_merkle_root: Option<TapBranchHash>,
+    pub tap_merkle_root: Option<TapNodeHash>,
     // Proprietary key-value pairs for this input.
     /// The issuance value
     pub issuance_value_amount: Option<u64>,
     /// The issuance value commitment
     pub issuance_value_comm: Option<secp256k1_zkp::PedersenCommitment>,
     /// Issuance value rangeproof
-    pub issuance_value_rangeproof: Option<Box<RangeProof>>,
+    pub issuance_value_rangeproof: Option<RangeProof>,
     /// Issuance keys rangeproof
-    pub issuance_keys_rangeproof: Option<Box<RangeProof>>,
-    /// Pegin Transaction. Should be a bitcoin::Transaction
+    pub issuance_keys_rangeproof: Option<RangeProof>,
+    /// Pegin Transaction. Should be a `bitcoin::Transaction`
     pub pegin_tx: Option<bitcoin::Transaction>,
     /// Pegin Transaction proof
     // TODO: Look for Merkle proof structs
@@ -257,43 +261,96 @@ pub struct Input {
     /// Pegin Value
     pub pegin_value: Option<u64>,
     /// Pegin Witness
-    pub pegin_witness: Option<Vec<Vec<u8>>>,
+    pub pegin_witness: Option<PeginWitness>,
     /// Issuance inflation keys
     pub issuance_inflation_keys: Option<u64>,
     /// Issuance inflation keys commitment
     pub issuance_inflation_keys_comm: Option<secp256k1_zkp::PedersenCommitment>,
     /// Issuance blinding nonce
-    pub issuance_blinding_nonce: Option<Tweak>,
+    pub issuance_blinding_nonce: Option<AssetBlindingNonce>,
     /// Issuance asset entropy
-    pub issuance_asset_entropy: Option<[u8; 32]>,
+    pub issuance_asset_entropy: Option<AssetEntropy>,
     /// input utxo rangeproof
-    pub in_utxo_rangeproof: Option<Box<RangeProof>>,
+    pub in_utxo_rangeproof: Option<RangeProof>,
     /// Proof that blinded issuance matches the commitment
-    pub in_issuance_blind_value_proof: Option<Box<RangeProof>>,
+    pub in_issuance_blind_value_proof: Option<RangeProof>,
     /// Proof that blinded inflation keys matches the corresponding commitment
-    pub in_issuance_blind_inflation_keys_proof: Option<Box<RangeProof>>,
+    pub in_issuance_blind_inflation_keys_proof: Option<RangeProof>,
+    /// The explicit amount of the input
+    pub amount: Option<u64>,
+    /// The blind value rangeproof
+    pub blind_value_proof: Option<RangeProof>,
+    /// The input explicit asset
+    pub asset: Option<AssetId>,
+    /// The blind asset surjection proof
+    pub blind_asset_proof: Option<SurjectionProof>,
+    /// Whether the issuance is blinded
+    pub blinded_issuance: Option<u8>,
     /// Other fields
-    #[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>>,
 }
 
 impl Default for Input {
     fn default() -> Self {
-        Self { non_witness_utxo: Default::default(), witness_utxo: Default::default(), partial_sigs: Default::default(), sighash_type: Default::default(), redeem_script: Default::default(), witness_script: Default::default(), bip32_derivation: Default::default(), final_script_sig: Default::default(), final_script_witness: Default::default(), ripemd160_preimages: Default::default(), sha256_preimages: Default::default(), hash160_preimages: Default::default(), hash256_preimages: Default::default(), previous_txid: Txid::all_zeros(), previous_output_index: Default::default(), sequence: Default::default(), required_time_locktime: Default::default(), required_height_locktime: Default::default(), tap_key_sig: Default::default(), tap_script_sigs: Default::default(), tap_scripts: Default::default(), tap_key_origins: Default::default(), tap_internal_key: Default::default(), tap_merkle_root: Default::default(), issuance_value_amount: Default::default(), issuance_value_comm: Default::default(), issuance_value_rangeproof: Default::default(), issuance_keys_rangeproof: Default::default(), pegin_tx: Default::default(), pegin_txout_proof: Default::default(), pegin_genesis_hash: Default::default(), pegin_claim_script: Default::default(), pegin_value: Default::default(), pegin_witness: Default::default(), issuance_inflation_keys: Default::default(), issuance_inflation_keys_comm: Default::default(), issuance_blinding_nonce: Default::default(), issuance_asset_entropy: Default::default(), in_utxo_rangeproof: Default::default(), in_issuance_blind_value_proof: Default::default(), in_issuance_blind_inflation_keys_proof: Default::default(), proprietary: Default::default(), unknown: Default::default() }
+        Self {
+            non_witness_utxo: None,
+            witness_utxo: None,
+            partial_sigs: BTreeMap::new(),
+            sighash_type: None,
+            redeem_script: None,
+            witness_script: None,
+            bip32_derivation: BTreeMap::new(),
+            final_script_sig: None,
+            final_script_witness: None,
+            ripemd160_preimages: BTreeMap::new(),
+            sha256_preimages: BTreeMap::new(),
+            hash160_preimages: BTreeMap::new(),
+            hash256_preimages: BTreeMap::new(),
+            previous_txid: Txid::COINBASE_PREVOUT,
+            previous_output_index: 0,
+            sequence: None,
+            required_time_locktime: None,
+            required_height_locktime: None,
+            tap_key_sig: None,
+            tap_script_sigs: BTreeMap::new(),
+            tap_scripts: BTreeMap::new(),
+            tap_key_origins: BTreeMap::new(),
+            tap_internal_key: None,
+            tap_merkle_root: None,
+            issuance_value_amount: None,
+            issuance_value_comm: None,
+            issuance_value_rangeproof: None,
+            issuance_keys_rangeproof: None,
+            pegin_tx: None,
+            pegin_txout_proof: None,
+            pegin_genesis_hash: None,
+            pegin_claim_script: None,
+            pegin_value: None,
+            pegin_witness: None,
+            issuance_inflation_keys: None,
+            issuance_inflation_keys_comm: None,
+            issuance_blinding_nonce: None,
+            issuance_asset_entropy: None,
+            in_utxo_rangeproof: None,
+            in_issuance_blind_value_proof: None,
+            in_issuance_blind_inflation_keys_proof: None,
+            amount: None,
+            blind_value_proof: None,
+            asset: None,
+            blind_asset_proof: None,
+            blinded_issuance: None,
+            proprietary: BTreeMap::new(),
+            unknown: BTreeMap::new(),
+        }
     }
 }
 
-/// A Signature hash type for the corresponding input. As of taproot upgrade, the signature hash
-/// type can be either [`SigHashType`] or [`SchnorrSigHashType`] but it is not possible to know
+/// A Signature hash type for the corresponding input.
+///
+/// As of taproot upgrade, the signature hash
+/// type can be either [`EcdsaSighashType`] or [`SchnorrSighashType`] but it is not possible to know
 /// directly which signature hash type the user is dealing with. Therefore, the user is responsible
 /// for converting to/from [`PsbtSighashType`] from/to the desired signature hash type they need.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -306,7 +363,7 @@ serde_string_impl!(PsbtSighashType, "a PsbtSighashType data");
 impl fmt::Display for PsbtSighashType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.schnorr_hash_ty() {
-            Some(SchnorrSigHashType::Reserved) | None => write!(f, "{:#x}", self.inner),
+            Some(SchnorrSighashType::Reserved) | None => write!(f, "{:#x}", self.inner),
             Some(schnorr_hash_ty) => fmt::Display::fmt(&schnorr_hash_ty, f),
         }
     }
@@ -322,8 +379,8 @@ impl FromStr for PsbtSighashType {
         // NB: some of Schnorr sighash types are non-standard for pre-taproot
         // inputs. We also do not support SIGHASH_RESERVED in verbatim form
         // ("0xFF" string should be used instead).
-        match SchnorrSigHashType::from_str(s) {
-            Ok(SchnorrSigHashType::Reserved) => {
+        match SchnorrSighashType::from_str(s) {
+            Ok(SchnorrSighashType::Reserved) => {
                 return Err(SighashTypeParseError {
                     unrecognized: s.to_owned(),
                 })
@@ -342,16 +399,16 @@ impl FromStr for PsbtSighashType {
         })
     }
 }
-impl From<EcdsaSigHashType> for PsbtSighashType {
-    fn from(ecdsa_hash_ty: EcdsaSigHashType) -> Self {
+impl From<EcdsaSighashType> for PsbtSighashType {
+    fn from(ecdsa_hash_ty: EcdsaSighashType) -> Self {
         PsbtSighashType {
             inner: ecdsa_hash_ty as u32,
         }
     }
 }
 
-impl From<SchnorrSigHashType> for PsbtSighashType {
-    fn from(schnorr_hash_ty: SchnorrSigHashType) -> Self {
+impl From<SchnorrSighashType> for PsbtSighashType {
+    fn from(schnorr_hash_ty: SchnorrSighashType) -> Self {
         PsbtSighashType {
             inner: schnorr_hash_ty as u32,
         }
@@ -359,26 +416,25 @@ impl From<SchnorrSigHashType> for PsbtSighashType {
 }
 
 impl PsbtSighashType {
-    /// Returns the [`SigHashType`] if the [`PsbtSighashType`] can be
+    /// Returns the [`EcdsaSighashType`] if the [`PsbtSighashType`] can be
     /// converted to one.
-    pub fn ecdsa_hash_ty(self) -> Option<EcdsaSigHashType> {
-        EcdsaSigHashType::from_standard(self.inner).ok()
+    pub fn ecdsa_hash_ty(self) -> Option<EcdsaSighashType> {
+        EcdsaSighashType::from_standard(self.inner).ok()
     }
 
-    /// Returns the [`SchnorrSigHashType`] if the [`PsbtSighashType`] can be
+    /// Returns the [`SchnorrSighashType`] if the [`PsbtSighashType`] can be
     /// converted to one.
-    pub fn schnorr_hash_ty(self) -> Option<SchnorrSigHashType> {
+    pub fn schnorr_hash_ty(self) -> Option<SchnorrSighashType> {
         if self.inner > 0xffu32 {
             None
         } else {
-            SchnorrSigHashType::from_u8(self.inner as u8)
+            SchnorrSighashType::from_u8(self.inner as u8)
         }
     }
 
     /// Creates a [`PsbtSighashType`] from a raw `u32`.
     ///
-    /// Allows construction of a non-standard or non-valid sighash flag
-    /// ([`SigHashType`], [`SchnorrSigHashType`] respectively).
+    /// Allows construction of a non-standard or non-valid sighash flag.
     pub fn from_u32(n: u32) -> PsbtSighashType {
         PsbtSighashType { inner: n }
     }
@@ -392,40 +448,45 @@ impl PsbtSighashType {
 }
 
 impl Input {
-    /// Obtains the [`EcdsaSigHashType`] for this input if one is specified. If no sighash type is
-    /// specified, returns [`EcdsaSigHashType::All`].
+    /// Obtains the [`EcdsaSighashType`] for this input if one is specified. If no sighash type is
+    /// specified, returns [`EcdsaSighashType::All`].
     ///
     /// # Errors
     ///
     /// If the `sighash_type` field is set to a non-standard ECDSA sighash value.
-    pub fn ecdsa_hash_ty(&self) -> Option<EcdsaSigHashType> {
+    pub fn ecdsa_hash_ty(&self) -> Option<EcdsaSighashType> {
         self.sighash_type
-            .map(|sighash_type| sighash_type.ecdsa_hash_ty())
-            .unwrap_or(Some(EcdsaSigHashType::All))
+            .map_or(
+                Some(EcdsaSighashType::All),
+                PsbtSighashType::ecdsa_hash_ty,
+            )
     }
 
-    /// Obtains the [`SchnorrSigHashType`] for this input if one is specified. If no sighash type is
-    /// specified, returns [`SchnorrSigHashType::Default`].
+    /// Obtains the [`SchnorrSighashType`] for this input if one is specified. If no sighash type is
+    /// specified, returns [`SchnorrSighashType::Default`].
     ///
     /// # Errors
     ///
     /// If the `sighash_type` field is set to a invalid Schnorr sighash value.
-    pub fn schnorr_hash_ty(&self) -> Option<SchnorrSigHashType> {
+    pub fn schnorr_hash_ty(&self) -> Option<SchnorrSighashType> {
         self.sighash_type
-            .map(|sighash_type| sighash_type.schnorr_hash_ty())
-            .unwrap_or(Some(SchnorrSigHashType::Default))
+            .map_or(
+                Some(SchnorrSighashType::Default),
+                PsbtSighashType::schnorr_hash_ty,
+            )
     }
 
     /// Create a psbt input from prevout
     /// without any issuance or pegins
     pub fn from_prevout(outpoint: OutPoint) -> Self {
-        let mut ret = Self::default();
-        ret.previous_output_index = outpoint.vout;
-        ret.previous_txid = outpoint.txid;
-        ret
+        Input {
+            previous_output_index: outpoint.vout,
+            previous_txid: outpoint.txid,
+            ..Default::default()
+        }
     }
 
-    /// Create a pset input from TxIn
+    /// Create a pset input from `TxIn`
     pub fn from_txin(txin: TxIn) -> Self {
         let mut ret = Self::from_prevout(txin.previous_output);
         let has_issuance = txin.has_issuance();
@@ -434,11 +495,11 @@ impl Input {
         ret.final_script_witness = Some(txin.witness.script_witness);
 
         if txin.is_pegin {
-            ret.previous_output_index |= 1 << 30;
+            ret.previous_output_index |= OUTPOINT_PEGIN_FLAG;
             ret.pegin_witness = Some(txin.witness.pegin_witness);
         }
         if has_issuance {
-            ret.previous_output_index |= 1 << 31;
+            ret.previous_output_index |= OUTPOINT_ISSUANCE_FLAG;
             ret.issuance_blinding_nonce = Some(txin.asset_issuance.asset_blinding_nonce);
             ret.issuance_asset_entropy = Some(txin.asset_issuance.asset_entropy);
             match txin.asset_issuance.amount {
@@ -450,33 +511,59 @@ impl Input {
                 confidential::Value::Null => {}
                 confidential::Value::Explicit(x) => ret.issuance_inflation_keys = Some(x),
                 confidential::Value::Confidential(comm) => {
-                    ret.issuance_inflation_keys_comm = Some(comm)
+                    ret.issuance_inflation_keys_comm = Some(comm);
                 }
             }
 
             // Witness
-            ret.issuance_keys_rangeproof = txin.witness.inflation_keys_rangeproof;
-            ret.issuance_value_rangeproof = txin.witness.amount_rangeproof;
+            ret.issuance_keys_rangeproof = if txin.witness.inflation_keys_rangeproof.is_empty() {
+                None
+            } else {
+                Some(txin.witness.inflation_keys_rangeproof)
+            };
+            ret.issuance_value_rangeproof = if txin.witness.amount_rangeproof.is_empty() {
+                None
+            } else {
+                Some(txin.witness.amount_rangeproof)
+            };
         }
         ret
     }
 
+    /// The outpoint spent by this input.
+    ///
+    /// The pegin and issuance flags, which are stored in the high bits of
+    /// [`Input::previous_output_index`], are masked off; use [`Input::is_pegin`]
+    /// and [`Input::has_issuance`] to query them. As in Elements Core, an
+    /// all-1's index (a coinbase input) has no flags and is returned as-is.
+    pub fn previous_outpoint(&self) -> OutPoint {
+        let vout = if self.previous_output_index == OUTPOINT_COINBASE_INDEX {
+            self.previous_output_index
+        } else {
+            self.previous_output_index & !(OUTPOINT_PEGIN_FLAG | OUTPOINT_ISSUANCE_FLAG)
+        };
+        OutPoint {
+            txid: self.previous_txid,
+            vout,
+        }
+    }
+
     /// Compute the issuance asset ids from pset. This function does not check
-    /// whether there is an issuance in this input. Returns (asset_id, token_id)
+    /// whether there is an issuance in this input. Returns (`asset_id`, `token_id`)
     pub fn issuance_ids(&self) -> (AssetId, AssetId) {
-        let issue_nonce = self.issuance_blinding_nonce.unwrap_or(ZERO_TWEAK);
-        let entropy = if issue_nonce == ZERO_TWEAK {
-            // new issuance
-            let prevout = OutPoint {
-                txid: self.previous_txid,
-                vout: self.previous_output_index,
-            };
-            let contract_hash =
-                ContractHash::from_inner(self.issuance_asset_entropy.unwrap_or_default());
+        let issue_nonce = self.issuance_blinding_nonce.unwrap_or_default();
+        let entropy = if issue_nonce.is_null() {
+            // new issuance; the entropy is computed over the outpoint without
+            // its pegin/issuance flags, as Elements Core does
+            let prevout = self.previous_outpoint();
+            let contract_hash = self
+                .issuance_asset_entropy
+                .unwrap_or_default()
+                .into_contract_hash();
             AssetId::generate_asset_entropy(prevout, contract_hash)
         } else {
             // re-issuance
-            sha256::Midstate::from_inner(self.issuance_asset_entropy.unwrap_or_default())
+            self.issuance_asset_entropy.unwrap_or_default()
         };
         let asset_id = AssetId::from_entropy(entropy);
         let token_id =
@@ -492,13 +579,13 @@ impl Input {
 
     /// If the Pset Input is pegin
     pub fn is_pegin(&self) -> bool {
-        self.previous_output_index & (1 << 30) != 0
+        self.previous_output_index & OUTPOINT_PEGIN_FLAG != 0
     }
 
     /// Get the issuance for this tx input
     pub fn asset_issuance(&self) -> AssetIssuance {
         AssetIssuance {
-            asset_blinding_nonce: *self.issuance_blinding_nonce.as_ref().unwrap_or(&ZERO_TWEAK),
+            asset_blinding_nonce: self.issuance_blinding_nonce.unwrap_or_default(),
             asset_entropy: self.issuance_asset_entropy.unwrap_or_default(),
             amount: match (self.issuance_value_amount, self.issuance_value_comm) {
                 (None, None) => confidential::Value::Null,
@@ -567,43 +654,43 @@ impl Map for Input {
             }
             PSET_IN_FINAL_SCRIPTWITNESS => {
                 impl_pset_insert_pair! {
-                    self.final_script_witness <= <raw_key: _>|<raw_value: Vec<Vec<u8>>>
+                    self.final_script_witness <= <raw_key: _>|<raw_value: crate::Witness>
                 }
             }
             PSET_IN_RIPEMD160 => {
-                pset_insert_hash_pair(
+                pset_insert_hash_pair::<ripemd160::HashEngine>(
                     &mut self.ripemd160_preimages,
                     raw_key,
-                    raw_value,
+                    &raw_value,
                     error::PsetHash::Ripemd,
                 )?;
             }
             PSET_IN_SHA256 => {
-                pset_insert_hash_pair(
+                pset_insert_hash_pair::<sha256::HashEngine>(
                     &mut self.sha256_preimages,
                     raw_key,
-                    raw_value,
+                    &raw_value,
                     error::PsetHash::Sha256,
                 )?;
             }
             PSET_IN_HASH160 => {
-                pset_insert_hash_pair(
+                pset_insert_hash_pair::<hash160::HashEngine>(
                     &mut self.hash160_preimages,
                     raw_key,
-                    raw_value,
+                    &raw_value,
                     error::PsetHash::Hash160,
                 )?;
             }
             PSET_IN_HASH256 => {
-                pset_insert_hash_pair(
+                pset_insert_hash_pair::<sha256d::HashEngine>(
                     &mut self.hash256_preimages,
                     raw_key,
-                    raw_value,
+                    &raw_value,
                     error::PsetHash::Hash256,
                 )?;
             }
             PSET_IN_PREVIOUS_TXID | PSET_IN_OUTPUT_INDEX => {
-                return Err(Error::DuplicateKey(raw_key))?;
+                return Err(Error::DuplicateKey(raw_key).into());
             }
             PSET_IN_SEQUENCE => {
                 impl_pset_insert_pair! {
@@ -627,7 +714,7 @@ impl Map for Input {
             }
             PSBT_IN_TAP_SCRIPT_SIG => {
                 impl_pset_insert_pair! {
-                    self.tap_script_sigs <= <raw_key: (bitcoin::XOnlyPublicKey, TapLeafHash)>|<raw_value: schnorr::SchnorrSig>
+                    self.tap_script_sigs <= <raw_key: (XOnlyPublicKey, TapLeafHash)>|<raw_value: schnorr::SchnorrSig>
                 }
             }
             PSBT_IN_TAP_LEAF_SCRIPT => {
@@ -637,74 +724,89 @@ impl Map for Input {
             }
             PSBT_IN_TAP_BIP32_DERIVATION => {
                 impl_pset_insert_pair! {
-                    self.tap_key_origins <= <raw_key: bitcoin::XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
+                    self.tap_key_origins <= <raw_key: XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
                 }
             }
             PSBT_IN_TAP_INTERNAL_KEY => {
                 impl_pset_insert_pair! {
-                    self.tap_internal_key <= <raw_key: _>|< raw_value: bitcoin::XOnlyPublicKey>
+                    self.tap_internal_key <= <raw_key: _>|< raw_value: XOnlyPublicKey>
                 }
             }
             PSBT_IN_TAP_MERKLE_ROOT => {
                 impl_pset_insert_pair! {
-                    self.tap_merkle_root <= <raw_key: _>|< raw_value: TapBranchHash>
+                    self.tap_merkle_root <= <raw_key: _>|< raw_value: TapNodeHash>
                 }
             }
             PSET_IN_PROPRIETARY => {
-                let prop_key = raw::ProprietaryKey::from_key(raw_key.clone())?;
+                let prop_key = raw::ProprietaryKey::from_key(&raw_key)?;
                 if prop_key.is_pset_key() {
                     match prop_key.subtype {
                         PSBT_ELEMENTS_IN_ISSUANCE_VALUE => {
-                            impl_pset_prop_insert_pair!(self.issuance_value_amount <= <raw_key: _> | <raw_value : u64>)
+                            impl_pset_prop_insert_pair!(self.issuance_value_amount <= <raw_key: _> | <raw_value : u64>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_VALUE_COMMITMENT => {
-                            impl_pset_prop_insert_pair!(self.issuance_value_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>)
+                            impl_pset_prop_insert_pair!(self.issuance_value_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_VALUE_RANGEPROOF => {
-                            impl_pset_prop_insert_pair!(self.issuance_value_rangeproof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.issuance_value_rangeproof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_KEYS_RANGEPROOF => {
-                            impl_pset_prop_insert_pair!(self.issuance_keys_rangeproof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.issuance_keys_rangeproof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_TX => {
-                            impl_pset_prop_insert_pair!(self.pegin_tx <= <raw_key: _> | <raw_value : bitcoin::Transaction>)
+                            impl_pset_prop_insert_pair!(self.pegin_tx <= <raw_key: _> | <raw_value : bitcoin::Transaction>);
                         }
                         // No support for TxOutProof struct yet
                         PSBT_ELEMENTS_IN_PEG_IN_TXOUT_PROOF => {
-                            impl_pset_prop_insert_pair!(self.pegin_txout_proof <= <raw_key: _> | <raw_value : Vec<u8>>)
+                            impl_pset_prop_insert_pair!(self.pegin_txout_proof <= <raw_key: _> | <raw_value : Vec<u8>>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_GENESIS => {
-                            impl_pset_prop_insert_pair!(self.pegin_genesis_hash <= <raw_key: _> | <raw_value : BlockHash>)
+                            impl_pset_prop_insert_pair!(self.pegin_genesis_hash <= <raw_key: _> | <raw_value : BlockHash>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_CLAIM_SCRIPT => {
-                            impl_pset_prop_insert_pair!(self.pegin_claim_script <= <raw_key: _> | <raw_value : Script>)
+                            impl_pset_prop_insert_pair!(self.pegin_claim_script <= <raw_key: _> | <raw_value : Script>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_VALUE => {
-                            impl_pset_prop_insert_pair!(self.pegin_value <= <raw_key: _> | <raw_value : u64>)
+                            impl_pset_prop_insert_pair!(self.pegin_value <= <raw_key: _> | <raw_value : u64>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_WITNESS => {
-                            impl_pset_prop_insert_pair!(self.pegin_witness <= <raw_key: _> | <raw_value : Vec<Vec<u8>>>)
+                            impl_pset_prop_insert_pair!(self.pegin_witness <= <raw_key: _> | <raw_value : PeginWitness>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS => {
-                            impl_pset_prop_insert_pair!(self.issuance_inflation_keys <= <raw_key: _> | <raw_value : u64>)
+                            impl_pset_prop_insert_pair!(self.issuance_inflation_keys <= <raw_key: _> | <raw_value : u64>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS_COMMITMENT => {
-                            impl_pset_prop_insert_pair!(self.issuance_inflation_keys_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>)
+                            impl_pset_prop_insert_pair!(self.issuance_inflation_keys_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_BLINDING_NONCE => {
-                            impl_pset_prop_insert_pair!(self.issuance_blinding_nonce <= <raw_key: _> | <raw_value : Tweak>)
+                            impl_pset_prop_insert_pair!(self.issuance_blinding_nonce <= <raw_key: _> | <raw_value : AssetBlindingNonce>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_ASSET_ENTROPY => {
-                            impl_pset_prop_insert_pair!(self.issuance_asset_entropy <= <raw_key: _> | <raw_value : [u8;32]>)
+                            impl_pset_prop_insert_pair!(self.issuance_asset_entropy <= <raw_key: _> | <raw_value : AssetEntropy>);
                         }
                         PSBT_ELEMENTS_IN_UTXO_RANGEPROOF => {
-                            impl_pset_prop_insert_pair!(self.in_utxo_rangeproof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.in_utxo_rangeproof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_BLIND_VALUE_PROOF => {
-                            impl_pset_prop_insert_pair!(self.in_issuance_blind_value_proof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.in_issuance_blind_value_proof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_BLIND_INFLATION_KEYS_PROOF => {
-                            impl_pset_prop_insert_pair!(self.in_issuance_blind_inflation_keys_proof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.in_issuance_blind_inflation_keys_proof <= <raw_key: _> | <raw_value : RangeProof>);
+                        }
+                        PSBT_ELEMENTS_IN_EXPLICIT_VALUE => {
+                            impl_pset_prop_insert_pair!(self.amount <= <raw_key: _> | <raw_value : u64>);
+                        }
+                        PSBT_ELEMENTS_IN_VALUE_PROOF => {
+                            impl_pset_prop_insert_pair!(self.blind_value_proof <= <raw_key: _> | <raw_value : RangeProof>);
+                        }
+                        PSBT_ELEMENTS_IN_EXPLICIT_ASSET => {
+                            impl_pset_prop_insert_pair!(self.asset <= <raw_key: _> | <raw_value : AssetId>);
+                        }
+                        PSBT_ELEMENTS_IN_ASSET_PROOF => {
+                            impl_pset_prop_insert_pair!(self.blind_asset_proof <= <raw_key: _> | <raw_value : SurjectionProof>);
+                        }
+                        PSBT_ELEMENTS_IN_BLINDED_ISSUANCE => {
+                            impl_pset_prop_insert_pair!(self.blinded_issuance <= <raw_key: _> | <raw_value : u8>);
                         }
                         _ => match self.proprietary.entry(prop_key) {
                             Entry::Vacant(empty_key) => {
@@ -713,8 +815,18 @@ impl Map for Input {
                             Entry::Occupied(_) => return Err(Error::DuplicateKey(raw_key).into()),
                         },
                     }
+                } else {
+                    match self.proprietary.entry(prop_key) {
+                        Entry::Vacant(empty_key) => {
+                            empty_key.insert(raw_value);
+                        }
+                        Entry::Occupied(_) => {
+                            return Err(Error::DuplicateKey(raw_key).into())
+                        }
+                    }
                 }
             }
+
             _ => match self.unknown.entry(raw_key) {
                 Entry::Vacant(empty_key) => {
                     empty_key.insert(raw_value);
@@ -727,7 +839,7 @@ impl Map for Input {
     }
 
     fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
+        let mut rv: Vec<raw::Pair> = Vec::default();
 
         impl_pset_get_pair! {
             rv.push(self.non_witness_utxo as <PSET_IN_NON_WITNESS_UTXO, _>)
@@ -904,14 +1016,34 @@ impl Map for Input {
             rv.push_prop(self.in_issuance_blind_inflation_keys_proof as <PSBT_ELEMENTS_IN_ISSUANCE_BLIND_INFLATION_KEYS_PROOF, _>)
         }
 
-        for (key, value) in self.proprietary.iter() {
+        impl_pset_get_pair! {
+            rv.push_prop(self.amount as <PSBT_ELEMENTS_IN_EXPLICIT_VALUE, _>)
+        }
+
+        impl_pset_get_pair! {
+            rv.push_prop(self.blind_value_proof as <PSBT_ELEMENTS_IN_VALUE_PROOF, _>)
+        }
+
+        impl_pset_get_pair! {
+            rv.push_prop(self.asset as <PSBT_ELEMENTS_IN_EXPLICIT_ASSET, _>)
+        }
+
+        impl_pset_get_pair! {
+            rv.push_prop(self.blind_asset_proof as <PSBT_ELEMENTS_IN_ASSET_PROOF, _>)
+        }
+
+        impl_pset_get_pair! {
+            rv.push_prop(self.blinded_issuance as <PSBT_ELEMENTS_IN_BLINDED_ISSUANCE, _>)
+        }
+
+        for (key, value) in &self.proprietary {
             rv.push(raw::Pair {
                 key: key.to_key(),
                 value: value.clone(),
             });
         }
 
-        for (key, value) in self.unknown.iter() {
+        for (key, value) in &self.unknown {
             rv.push(raw::Pair {
                 key: key.clone(),
                 value: value.clone(),
@@ -978,6 +1110,11 @@ impl Map for Input {
         merge!(in_utxo_rangeproof, self, other);
         merge!(in_issuance_blind_value_proof, self, other);
         merge!(in_issuance_blind_inflation_keys_proof, self, other);
+        merge!(amount, self, other);
+        merge!(blind_value_proof, self, other);
+        merge!(asset, self, other);
+        merge!(blind_asset_proof, self, other);
+        merge!(blinded_issuance, self, other);
         Ok(())
     }
 }
@@ -1036,33 +1173,141 @@ impl Decodable for Input {
     }
 }
 
-fn pset_insert_hash_pair<H>(
-    map: &mut BTreeMap<H, Vec<u8>>,
+fn pset_insert_hash_pair<Eng>(
+    map: &mut BTreeMap<Eng::Hash, Vec<u8>>,
     raw_key: raw::Key,
-    raw_value: Vec<u8>,
+    raw_value: &[u8],
     hash_type: error::PsetHash,
 ) -> Result<(), encode::Error>
 where
-    H: hashes::Hash + serialize::Deserialize,
+    Eng: hashes::HashEngine + Default,
+    Eng::Hash: serialize::Deserialize,
 {
     if raw_key.key.is_empty() {
         return Err(pset::Error::InvalidKey(raw_key).into());
     }
-    let key_val: H = serialize::Deserialize::deserialize(&raw_key.key)?;
+    let key_val: Eng::Hash = serialize::Deserialize::deserialize(&raw_key.key)?;
     match map.entry(key_val) {
         Entry::Vacant(empty_key) => {
-            let val: Vec<u8> = serialize::Deserialize::deserialize(&raw_value)?;
-            if <H as hashes::Hash>::hash(&val) != key_val {
+            let val: Vec<u8> = serialize::Deserialize::deserialize(raw_value)?;
+            let mut eng = Eng::default();
+            eng.input(&val);
+            if eng.finalize() != key_val {
                 return Err(pset::Error::InvalidPreimageHashPair {
                     preimage: val,
-                    hash: Vec::from(key_val.borrow()),
-                    hash_type: hash_type,
+                    hash: key_val.as_byte_array().as_ref().to_vec(),
+                    hash_type,
                 }
                 .into());
             }
             empty_key.insert(val);
             Ok(())
         }
-        Entry::Occupied(_) => return Err(pset::Error::DuplicateKey(raw_key).into()),
+        Entry::Occupied(_) => Err(pset::Error::DuplicateKey(raw_key).into()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{AssetBlindingNonce, confidential};
+    use crate::pset::PartiallySignedTransaction;
+    use crate::{AssetEntropy, AssetIssuance, LockTime, Transaction, TxIn, TxInWitness};
+
+    const DUMMY_ENTROPY: AssetEntropy = AssetEntropy::from_byte_array([1; 32]);
+
+    fn dummy_outpoint() -> OutPoint {
+        OutPoint::new(Txid::from_byte_array([7; 32]), 3)
+    }
+
+    /// A pegin input which also carries a (new) asset issuance, so that both
+    /// flag bits are set on the PSET previous output index.
+    fn pegin_issuance_txin() -> TxIn {
+        TxIn {
+            previous_output: dummy_outpoint(),
+            is_pegin: true,
+            asset_issuance: AssetIssuance {
+                asset_blinding_nonce: AssetBlindingNonce::NEW_ISSUANCE,
+                asset_entropy: DUMMY_ENTROPY,
+                amount: confidential::Value::Explicit(1000),
+                inflation_keys: confidential::Value::Explicit(1),
+            },
+            witness: TxInWitness::empty(),
+            ..TxIn::default()
+        }
+    }
+
+    #[test]
+    fn previous_outpoint_masks_flags() {
+        let txin = pegin_issuance_txin();
+        let input = Input::from_txin(txin.clone());
+
+        // The flags live in the PSET index...
+        assert_eq!(
+            input.previous_output_index,
+            3 | OUTPOINT_PEGIN_FLAG | OUTPOINT_ISSUANCE_FLAG,
+        );
+        assert!(input.is_pegin());
+        assert!(input.has_issuance());
+        // ...but not in the outpoint.
+        assert_eq!(input.previous_outpoint(), dummy_outpoint());
+        assert_eq!(input.previous_outpoint(), txin.previous_output);
+    }
+
+    #[test]
+    fn previous_outpoint_leaves_coinbase_index_alone() {
+        // An all-1's index is a coinbase input, not a flagged index.
+        let input = Input::from_prevout(OutPoint::null());
+        assert_eq!(input.previous_output_index, OUTPOINT_COINBASE_INDEX);
+        assert_eq!(input.previous_outpoint(), OutPoint::null());
+    }
+
+    // The asset entropy commits to the outpoint being spent, so it must be computed
+    // over the unflagged index, exactly as `TxIn::issuance_ids` does.
+    #[test]
+    fn issuance_ids_ignore_outpoint_flags() {
+        let txin = pegin_issuance_txin();
+        let input = Input::from_txin(txin.clone());
+
+        assert_eq!(input.issuance_ids(), txin.issuance_ids());
+    }
+
+    // See `pset::map::output::tests::from_tx_does_not_spuriously_set_proofs_on_unblinded_outputs`.
+    // Same principle, but for the asset issuance rangeproofs in the input witnesses.
+    #[test]
+    fn from_tx_does_not_spuriously_set_proofs_on_explicit_issuance() {
+        let txin = TxIn {
+            asset_issuance: AssetIssuance {
+                asset_blinding_nonce: AssetBlindingNonce::NEW_ISSUANCE,
+                asset_entropy: DUMMY_ENTROPY,
+                amount: confidential::Value::Explicit(1000),
+                inflation_keys: confidential::Value::Null,
+            },
+            witness: TxInWitness::empty(),
+            ..TxIn::default()
+        };
+        assert!(txin.has_issuance());
+        assert!(txin.witness.amount_rangeproof.is_empty());
+        assert!(txin.witness.inflation_keys_rangeproof.is_empty());
+
+        let tx = Transaction {
+            version: 2,
+            lock_time: LockTime::ZERO,
+            input: vec![txin],
+            output: vec![],
+        };
+
+        let pset = PartiallySignedTransaction::from_tx(tx);
+        let input = &pset.inputs()[0];
+        assert!(
+            input.issuance_value_rangeproof.is_none(),
+            "issuance_value_rangeproof should be None for an explicit issuance, got {:?}",
+            input.issuance_value_rangeproof,
+        );
+        assert!(
+            input.issuance_keys_rangeproof.is_none(),
+            "issuance_keys_rangeproof should be None for an explicit issuance, got {:?}",
+            input.issuance_keys_rangeproof,
+        );
     }
 }
diff --git a/src/pset/map/output.rs b/src/pset/map/output.rs
index 03be1a4d..04c23d1d 100644
--- a/src/pset/map/output.rs
+++ b/src/pset/map/output.rs
@@ -23,44 +23,44 @@ use crate::pset::map::Map;
 use crate::pset::raw;
 use crate::pset::Error;
 use crate::{confidential, pset};
-use crate::{encode, Script, TxOutWitness};
-use bitcoin::util::bip32::KeySource;
-use bitcoin::{self, PublicKey};
-use secp256k1_zkp::{self, Generator, RangeProof, SurjectionProof};
+use crate::{encode, RangeProof, Script, TxOutWitness, SurjectionProof};
+use bitcoin::bip32::KeySource;
+use bitcoin::{PublicKey, key::XOnlyPublicKey};
+use secp256k1_zkp::{self, Generator};
 
 use crate::issuance;
 
 use crate::AssetId;
 use crate::TxOut;
 
-/// Type: Redeem Script PSET_OUT_REDEEM_SCRIPT = 0x00
+/// Type: Redeem Script `PSET_OUT_REDEEM_SCRIPT` = 0x00
 const PSET_OUT_REDEEM_SCRIPT: u8 = 0x00;
-/// Type: Witness Script PSET_OUT_WITNESS_SCRIPT = 0x01
+/// Type: Witness Script `PSET_OUT_WITNESS_SCRIPT` = 0x01
 const PSET_OUT_WITNESS_SCRIPT: u8 = 0x01;
-/// Type: BIP 32 Derivation Path PSET_OUT_BIP32_DERIVATION = 0x02
+/// Type: BIP 32 Derivation Path `PSET_OUT_BIP32_DERIVATION` = 0x02
 const PSET_OUT_BIP32_DERIVATION: u8 = 0x02;
-/// Type: Output Amount PSET_OUT_AMOUNT = 0x03
+/// Type: Output Amount `PSET_OUT_AMOUNT` = 0x03
 const PSET_OUT_AMOUNT: u8 = 0x03;
-/// Type: Output Script PSET_OUT_SCRIPT = 0x04
+/// Type: Output Script `PSET_OUT_SCRIPT` = 0x04
 const PSET_OUT_SCRIPT: u8 = 0x04;
-/// Type: Taproot Internal Key PSBT_OUT_TAP_INTERNAL_KEY = 0x05
+/// Type: Taproot Internal Key `PSBT_OUT_TAP_INTERNAL_KEY` = 0x05
 const PSBT_OUT_TAP_INTERNAL_KEY: u8 = 0x05;
-/// Type: Taproot Tree PSBT_OUT_TAP_TREE = 0x06
+/// Type: Taproot Tree `PSBT_OUT_TAP_TREE` = 0x06
 const PSBT_OUT_TAP_TREE: u8 = 0x06;
-/// Type: Taproot Key BIP 32 Derivation Path PSBT_OUT_TAP_BIP32_DERIVATION = 0x07
+/// Type: Taproot Key BIP 32 Derivation Path `PSBT_OUT_TAP_BIP32_DERIVATION` = 0x07
 const PSBT_OUT_TAP_BIP32_DERIVATION: u8 = 0x07;
-/// Type: Proprietary Use Type PSET_IN_PROPRIETARY = 0xFC
+/// Type: Proprietary Use Type `PSET_IN_PROPRIETARY` = 0xFC
 const PSET_OUT_PROPRIETARY: u8 = 0xFC;
 
 /// Elements
 /// The 33 byte Value Commitment for this output. This is mutually
-/// exclusive with PSBT_OUT_VALUE.
+/// exclusive with `PSBT_OUT_VALUE`.
 const PSBT_ELEMENTS_OUT_VALUE_COMMITMENT: u8 = 0x01;
 /// The explicit 32 byte asset tag for this output. This is mutually
-/// exclusive with PSBT_ELEMENTS_OUT_ASSET_COMMITMENT.
+/// exclusive with `PSBT_ELEMENTS_OUT_ASSET_COMMITMENT`.
 const PSBT_ELEMENTS_OUT_ASSET: u8 = 0x02;
 /// The 33 byte Asset Commitment for this output. This is mutually
-/// exclusive with PSBT_ELEMENTS_OUT_ASSET.
+/// exclusive with `PSBT_ELEMENTS_OUT_ASSET`.
 const PSBT_ELEMENTS_OUT_ASSET_COMMITMENT: u8 = 0x03;
 /// The rangeproof for the value of this output.
 const PSBT_ELEMENTS_OUT_VALUE_RANGEPROOF: u8 = 0x04;
@@ -74,20 +74,19 @@ const PSBT_ELEMENTS_OUT_ECDH_PUBKEY: u8 = 0x07;
 /// whose owner should blind this output.
 const PSBT_ELEMENTS_OUT_BLINDER_INDEX: u8 = 0x08;
 /// An explicit value rangeproof that proves that the value commitment in
-/// PSBT_ELEMENTS_OUT_VALUE_COMMITMENT matches the explicit value in PSBT_OUT_VALUE.
-/// If provided, PSBT_ELEMENTS_OUT_VALUE_COMMITMENT must be provided too.
+/// `PSBT_ELEMENTS_OUT_VALUE_COMMITMENT` matches the explicit value in `PSBT_OUT_VALUE`.
+/// If provided, `PSBT_ELEMENTS_OUT_VALUE_COMMITMENT` must be provided too.
 const PSBT_ELEMENTS_OUT_BLIND_VALUE_PROOF: u8 = 0x09;
 /// An asset surjection proof with this output's asset as the only asset in the
 /// input set in order to prove that the asset commitment in
-/// PSBT_ELEMENTS_OUT_ASSET_COMMITMENT matches the explicit asset in
-/// PSBT_ELEMENTS_OUT_ASSET. If provided, PSBT_ELEMENTS_OUT_ASSET_COMMITMENT must
+/// `PSBT_ELEMENTS_OUT_ASSET_COMMITMENT` matches the explicit asset in
+/// `PSBT_ELEMENTS_OUT_ASSET`. If provided, `PSBT_ELEMENTS_OUT_ASSET_COMMITMENT` must
 /// be provided too.
 const PSBT_ELEMENTS_OUT_BLIND_ASSET_PROOF: u8 = 0x0a;
 
 /// A key-value map for an output of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Output {
     /// The redeem script for this output.
     pub redeem_script: Option<Script>,
@@ -95,15 +94,13 @@ pub struct Output {
     pub witness_script: Option<Script>,
     /// 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<PublicKey, KeySource>,
     /// The internal pubkey
-    pub tap_internal_key: Option<bitcoin::XOnlyPublicKey>,
+    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<bitcoin::XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
+    pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
     /// (PSET) The explicit amount of the output
     pub amount: Option<u64>,
     /// (PSET) The out amount commitment
@@ -116,9 +113,9 @@ pub struct Output {
     pub asset_comm: Option<secp256k1_zkp::Generator>,
     // Proprietary key-value pairs for this output.
     /// Output value rangeproof
-    pub value_rangeproof: Option<Box<RangeProof>>,
+    pub value_rangeproof: Option<RangeProof>,
     /// Output Asset surjection proof
-    pub asset_surjection_proof: Option<Box<SurjectionProof>>,
+    pub asset_surjection_proof: Option<SurjectionProof>,
     /// Blinding pubkey which is used in receiving address
     pub blinding_key: Option<bitcoin::PublicKey>,
     /// The ephermal pk sampled by sender
@@ -126,27 +123,18 @@ pub struct Output {
     /// The index of the input whose owner should blind this output
     pub blinder_index: Option<u32>,
     /// The blind value rangeproof
-    pub blind_value_proof: Option<Box<RangeProof>>,
+    pub blind_value_proof: Option<RangeProof>,
     /// The blind asset surjection proof
-    pub blind_asset_proof: Option<Box<SurjectionProof>>,
+    pub blind_asset_proof: Option<SurjectionProof>,
     /// Pset
     /// Other fields
-    #[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>>,
 }
 
 /// Taproot Tree representing a finalized [`TaprootBuilder`] (a complete binary tree)
 #[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct TapTree(pub(crate) TaprootBuilder);
 
 impl PartialEq for TapTree {
@@ -192,19 +180,19 @@ impl Output {
         script: Script,
         amount: u64,
         asset: AssetId,
-        blinding_key: Option<bitcoin::PublicKey>,
+        blinding_key: Option<PublicKey>,
     ) -> Self {
-        let mut res = pset::Output::default();
-        // set the respective values
-        res.script_pubkey = script;
-        res.amount = Some(amount);
-        res.blinding_key = blinding_key;
-        res.asset = Some(asset);
-        res
+        pset::Output {
+            script_pubkey: script,
+            amount: Some(amount),
+            blinding_key,
+            asset: Some(asset),
+            ..Self::default()
+        }
     }
 
     /// Create a output from txout
-    /// If the txout it [TxOut::is_partially_blinded], then nonce of the txout
+    /// If the txout it [`TxOut::is_partially_blinded`], then nonce of the txout
     /// is treated as ecdh pubkey, otherwise the nonce of the txout is assumed to
     /// be receiver blinding key.
     /// This is to be used when the txout is not blinded. This sets
@@ -222,19 +210,27 @@ impl Output {
             confidential::Asset::Confidential(comm) => rv.asset_comm = Some(comm),
         }
         if txout.is_partially_blinded() {
-            rv.ecdh_pubkey = txout.nonce.commitment().map(|pk| bitcoin::PublicKey {
+            rv.ecdh_pubkey = txout.nonce.commitment().map(|pk| PublicKey {
                 inner: pk,
                 compressed: true, // always serialize none as compressed pk
             });
         } else {
-            rv.blinding_key = txout.nonce.commitment().map(|pk| bitcoin::PublicKey {
+            rv.blinding_key = txout.nonce.commitment().map(|pk| PublicKey {
                 inner: pk,
                 compressed: true, // always serialize none as compressed pk
             });
         }
         rv.script_pubkey = txout.script_pubkey;
-        rv.value_rangeproof = txout.witness.rangeproof;
-        rv.asset_surjection_proof = txout.witness.surjection_proof;
+        rv.value_rangeproof = if txout.witness.rangeproof.is_empty() {
+            None
+        } else {
+            Some(txout.witness.rangeproof)
+        };
+        rv.asset_surjection_proof = if txout.witness.surjection_proof.is_empty() {
+            None
+        } else {
+            Some(txout.witness.surjection_proof)
+        };
         rv
     }
 
@@ -261,19 +257,23 @@ impl Output {
             .unwrap_or_default(),
             script_pubkey: self.script_pubkey.clone(),
             witness: TxOutWitness {
-                surjection_proof: self.asset_surjection_proof.clone(),
-                rangeproof: self.value_rangeproof.clone(),
+                surjection_proof: self.asset_surjection_proof
+                    .clone()
+                    .unwrap_or(SurjectionProof::EMPTY),
+                rangeproof: self.value_rangeproof
+                    .clone()
+                    .unwrap_or(RangeProof::EMPTY),
             },
         }
     }
 
-    /// IsBlinded from elements core
+    /// `IsBlinded` from elements core
     /// This indicates whether the output is marked for blinding
     pub fn is_marked_for_blinding(&self) -> bool {
         self.blinding_key.is_some()
     }
 
-    /// IsPartiallyBlinded from elements core
+    /// `IsPartiallyBlinded` from elements core
     pub fn is_partially_blinded(&self) -> bool {
         self.is_marked_for_blinding()
             && (self.amount_comm.is_some()
@@ -283,7 +283,7 @@ impl Output {
                 || self.ecdh_pubkey.is_some())
     }
 
-    /// IsFullyBlinded from elements core
+    /// `IsFullyBlinded` from elements core
     pub fn is_fully_blinded(&self) -> bool {
         self.is_marked_for_blinding()
             && self.amount_comm.is_some()
@@ -326,7 +326,7 @@ impl Map for Output {
 
             PSBT_OUT_TAP_INTERNAL_KEY => {
                 impl_pset_insert_pair! {
-                    self.tap_internal_key <= <raw_key: _>|<raw_value: bitcoin::XOnlyPublicKey>
+                    self.tap_internal_key <= <raw_key: _>|<raw_value: XOnlyPublicKey>
                 }
             }
             PSBT_OUT_TAP_TREE => {
@@ -336,50 +336,50 @@ impl Map for Output {
             }
             PSBT_OUT_TAP_BIP32_DERIVATION => {
                 impl_pset_insert_pair! {
-                    self.tap_key_origins <= <raw_key: bitcoin::XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
+                    self.tap_key_origins <= <raw_key: XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
                 }
             }
 
             PSET_OUT_PROPRIETARY => {
-                let prop_key = raw::ProprietaryKey::from_key(raw_key.clone())?;
+                let prop_key = raw::ProprietaryKey::from_key(&raw_key)?;
                 if prop_key.is_pset_key() {
                     match prop_key.subtype {
                         PSBT_ELEMENTS_OUT_VALUE_COMMITMENT => {
-                            impl_pset_prop_insert_pair!(self.amount_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>)
+                            impl_pset_prop_insert_pair!(self.amount_comm <= <raw_key: _> | <raw_value : secp256k1_zkp::PedersenCommitment>);
                         }
                         PSBT_ELEMENTS_OUT_ASSET => {
-                            impl_pset_prop_insert_pair!(self.asset <= <raw_key: _> | <raw_value : AssetId>)
+                            impl_pset_prop_insert_pair!(self.asset <= <raw_key: _> | <raw_value : AssetId>);
                         }
                         PSBT_ELEMENTS_OUT_ASSET_COMMITMENT => {
-                            impl_pset_prop_insert_pair!(self.asset_comm <= <raw_key: _> | <raw_value : Generator>)
+                            impl_pset_prop_insert_pair!(self.asset_comm <= <raw_key: _> | <raw_value : Generator>);
                         }
                         PSBT_ELEMENTS_OUT_VALUE_RANGEPROOF => {
-                            impl_pset_prop_insert_pair!(self.value_rangeproof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.value_rangeproof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_OUT_ASSET_SURJECTION_PROOF => {
-                            impl_pset_prop_insert_pair!(self.asset_surjection_proof <= <raw_key: _> | <raw_value : Box<SurjectionProof>>)
+                            impl_pset_prop_insert_pair!(self.asset_surjection_proof <= <raw_key: _> | <raw_value : SurjectionProof>);
                         }
                         PSBT_ELEMENTS_OUT_BLINDING_PUBKEY => {
-                            impl_pset_prop_insert_pair!(self.blinding_key <= <raw_key: _> | <raw_value : bitcoin::PublicKey>)
+                            impl_pset_prop_insert_pair!(self.blinding_key <= <raw_key: _> | <raw_value : PublicKey>);
                         }
                         PSBT_ELEMENTS_OUT_ECDH_PUBKEY => {
-                            impl_pset_prop_insert_pair!(self.ecdh_pubkey <= <raw_key: _> | <raw_value : bitcoin::PublicKey>)
+                            impl_pset_prop_insert_pair!(self.ecdh_pubkey <= <raw_key: _> | <raw_value : PublicKey>);
                         }
                         PSBT_ELEMENTS_OUT_BLINDER_INDEX => {
-                            impl_pset_prop_insert_pair!(self.blinder_index <= <raw_key: _> | <raw_value : u32>)
+                            impl_pset_prop_insert_pair!(self.blinder_index <= <raw_key: _> | <raw_value : u32>);
                         }
                         PSBT_ELEMENTS_OUT_BLIND_VALUE_PROOF => {
-                            impl_pset_prop_insert_pair!(self.blind_value_proof <= <raw_key: _> | <raw_value : Box<RangeProof>>)
+                            impl_pset_prop_insert_pair!(self.blind_value_proof <= <raw_key: _> | <raw_value : RangeProof>);
                         }
                         PSBT_ELEMENTS_OUT_BLIND_ASSET_PROOF => {
-                            impl_pset_prop_insert_pair!(self.blind_asset_proof <= <raw_key: _> | <raw_value : Box<SurjectionProof>>)
+                            impl_pset_prop_insert_pair!(self.blind_asset_proof <= <raw_key: _> | <raw_value : SurjectionProof>);
                         }
                         _ => match self.proprietary.entry(prop_key) {
                             Entry::Vacant(empty_key) => {
                                 empty_key.insert(raw_value);
                             }
                             Entry::Occupied(_) => {
-                                return Err(Error::DuplicateKey(raw_key.clone()).into())
+                                return Err(Error::DuplicateKey(raw_key).into())
                             }
                         },
                     }
@@ -389,7 +389,7 @@ impl Map for Output {
                             empty_key.insert(raw_value);
                         }
                         Entry::Occupied(_) => {
-                            return Err(Error::DuplicateKey(raw_key.clone()).into())
+                            return Err(Error::DuplicateKey(raw_key).into())
                         }
                     }
                 }
@@ -407,7 +407,7 @@ impl Map for Output {
     }
 
     fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
+        let mut rv: Vec<raw::Pair> = Vec::default();
 
         impl_pset_get_pair! {
             rv.push(self.redeem_script as <PSET_OUT_REDEEM_SCRIPT, _>)
@@ -488,14 +488,14 @@ impl Map for Output {
             rv.push_prop(self.blind_asset_proof as <PSBT_ELEMENTS_OUT_BLIND_ASSET_PROOF, _>)
         }
 
-        for (key, value) in self.proprietary.iter() {
+        for (key, value) in &self.proprietary {
             rv.push(raw::Pair {
                 key: key.to_key(),
                 value: value.clone(),
             });
         }
 
-        for (key, value) in self.unknown.iter() {
+        for (key, value) in &self.unknown {
             rv.push(raw::Pair {
                 key: key.clone(),
                 value: value.clone(),
@@ -584,3 +584,59 @@ impl Decodable for Output {
         Ok(rv)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::pset::{raw, Map, PartiallySignedTransaction};
+    use crate::{encode, Transaction};
+
+    // Regression test from Claude that the next two commits do not cause
+    // `Pset::from_tx` to insert 0-length proofs when given unblinded outputs.
+    // It should insert no proofs at all.
+    #[test]
+    fn from_tx_does_not_spuriously_set_proofs_on_unblinded_outputs() {
+        // Fully-explicit transaction from `test_pset` in mod.rs
+        let tx_hex = "010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000";
+        let tx: Transaction =
+            encode::deserialize(&hex::decode_to_vec(tx_hex).unwrap()).unwrap();
+        assert!(tx.output.iter().all(|o| o.witness.is_empty()), "fixture must be unblinded");
+
+        let pset = PartiallySignedTransaction::from_tx(tx);
+        for (i, out) in pset.outputs().iter().enumerate() {
+            assert!(
+                out.value_rangeproof.is_none(),
+                "output {i}: value_rangeproof should be None for an unblinded output, got {:?}",
+                out.value_rangeproof,
+            );
+            assert!(
+                out.asset_surjection_proof.is_none(),
+                "output {i}: asset_surjection_proof should be None for an unblinded output, got {:?}",
+                out.asset_surjection_proof,
+            );
+        }
+
+        // Wire-format check: an unblinded output's key-value pairs must not
+        // include the value-rangeproof / asset-surjection-proof proprietary
+        // keys at all (subtypes 0x04/0x05 per PSBT_ELEMENTS_OUT_VALUE_RANGEPROOF/
+        // PSBT_ELEMENTS_OUT_ASSET_SURJECTION_PROOF in pset/map/output.rs), not
+        // even with an empty value. `Map::get_pairs` is exactly what
+        // `consensus_encode` iterates over (see `impl_pset_consensus_encoding!`
+        // in pset/macros.rs), so this checks the real wire format rather than
+        // grepping serialized bytes.
+        let value_rangeproof_key = raw::ProprietaryKey::from_pset_pair(0x04, vec![]).to_key();
+        let asset_surjection_proof_key = raw::ProprietaryKey::from_pset_pair(0x05, vec![]).to_key();
+        for (i, out) in pset.outputs().iter().enumerate() {
+            let pairs = Map::get_pairs(out).unwrap();
+            assert!(
+                !pairs.iter().any(|p| p.key == value_rangeproof_key),
+                "output {i}: serialized pairs unexpectedly contain a value-rangeproof key: {:?}",
+                pairs,
+            );
+            assert!(
+                !pairs.iter().any(|p| p.key == asset_surjection_proof_key),
+                "output {i}: serialized pairs unexpectedly contain an asset-surjection-proof key: {:?}",
+                pairs,
+            );
+        }
+    }
+}
diff --git a/src/pset/mod.rs b/src/pset/mod.rs
index 4d1ac20e..d4f254be 100644
--- a/src/pset/mod.rs
+++ b/src/pset/mod.rs
@@ -15,12 +15,12 @@
 //! # Partially Signed Elements Transactions (PSET)
 //!
 //! Implementation of BIP174 Partially Signed Bitcoin Transaction Format as
-//! defined at https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
-//! except we define PSETs containing non-standard SigHash types as invalid.
+//! defined at <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
+//! except we define PSETs containing non-standard Sighash types as invalid.
 //! Extension for PSET is based on PSET defined in BIP370.
-//! https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
+//! <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::{cmp, io};
 
 mod error;
@@ -29,27 +29,35 @@ mod macros;
 mod map;
 pub mod raw;
 pub mod serialize;
+pub mod elip100;
+pub mod elip102;
+
+#[cfg(feature = "base64")]
+mod str;
+
+#[cfg(feature = "base64")]
+pub use self::str::ParseError;
 
-use crate::blind::{BlindAssetProofs, BlindValueProofs};
 use crate::confidential;
 use crate::encode::{self, Decodable, Encodable};
 use crate::{
     blind::RangeProofMessage,
     confidential::{AssetBlindingFactor, ValueBlindingFactor},
-    TxOutSecrets,
+    RangeProof, SurjectionProof, TxOutSecrets,
+};
+use crate::{
+    LockTime, Sequence, SurjectionInput, Transaction, TxIn,
+    TxInWitness, TxOut, TxOutWitness, Txid, CtLocation, CtLocationType,
 };
-use crate::{OutPoint, LockTime, Sequence, SurjectionInput, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness, Txid};
-use bitcoin;
 use secp256k1_zkp::rand::{CryptoRng, RngCore};
-use secp256k1_zkp::{self, RangeProof, SecretKey, SurjectionProof};
+use secp256k1_zkp::{self, SecretKey};
 
-pub use self::error::{Error, PsetBlindError};
+pub use self::error::{Error, PsetBlindError, PsetHash};
 use self::map::Map;
 pub use self::map::{Global, GlobalTxData, Input, Output, PsbtSighashType, TapTree};
 
 /// A Partially Signed Transaction.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct PartiallySignedTransaction {
     /// The key-value pairs for all global data.
     pub global: Global,
@@ -70,25 +78,26 @@ impl Default for PartiallySignedTransaction {
 impl PartiallySignedTransaction {
     /// Create a new PSET from a raw transaction
     pub fn from_tx(tx: Transaction) -> Self {
-        let mut global = Global::default();
-        global.tx_data.output_count = tx.output.len();
-        global.tx_data.input_count = tx.input.len();
-        global.tx_data.fallback_locktime = Some(tx.lock_time);
-        global.tx_data.version = tx.version;
+        let global = Global {
+            tx_data: GlobalTxData {
+                output_count: tx.output.len(),
+                input_count: tx.input.len(),
+                fallback_locktime: Some(tx.lock_time),
+                version: tx.version,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
 
         let inputs = tx.input.into_iter().map(Input::from_txin).collect();
         let outputs = tx
             .output
             .into_iter()
-            .map(|o| Output::from_txout(o))
+            .map(Output::from_txout)
             .collect();
-        Self {
-            global: global,
-            inputs: inputs,
-            outputs: outputs,
-        }
+        Self { global, inputs, outputs }
     }
-    /// Create a PartiallySignedTransaction with zero inputs
+    /// Create a `PartiallySignedTransaction` with zero inputs
     /// zero outputs with a version 2 and tx version 2
     pub fn new_v2() -> Self {
         PartiallySignedTransaction {
@@ -172,7 +181,7 @@ impl PartiallySignedTransaction {
     /// Remove the output at `index` and return it if any, otherwise returns None
     /// This also updates the pset global output count
     pub fn remove_output(&mut self, index: usize) -> Option<Output> {
-        if self.inputs.get(index).is_some() {
+        if self.outputs.get(index).is_some() {
             self.global.tx_data.output_count -= 1;
             return Some(self.outputs.remove(index));
         }
@@ -190,6 +199,7 @@ impl PartiallySignedTransaction {
     }
 
     /// Accessor for the locktime to be used in the final transaction
+    #[allow(clippy::match_single_binding)]
     pub fn locktime(&self) -> Result<LockTime, Error> {
         match self.global.tx_data {
             GlobalTxData {
@@ -227,7 +237,7 @@ impl PartiallySignedTransaction {
 
                 match (time_locktime, height_locktime) {
                     (Locktime::Unconstrained, Locktime::Unconstrained) => {
-                        Ok(fallback_locktime.map(LockTime::from).unwrap_or(LockTime::ZERO))
+                        Ok(fallback_locktime.unwrap_or(LockTime::ZERO))
                     }
                     (Locktime::Minimum(x), _) => Ok(x.into()),
                     (_, Locktime::Minimum(x)) => Ok(x.into()),
@@ -248,7 +258,7 @@ impl PartiallySignedTransaction {
         // changed by Updaters and Combiners, the sequence number in this unsigned
         // transaction must be set to 0 (not final, nor the sequence in PSBT_IN_SEQUENCE).
         // The lock time in this unsigned transaction must be computed as described previously.
-        for inp in tx.input.iter_mut() {
+        for inp in &mut tx.input {
             inp.sequence = Sequence::from_height(0);
         }
         Ok(tx.txid())
@@ -265,7 +275,7 @@ impl PartiallySignedTransaction {
         }
     }
 
-    /// Extract the Transaction from a PartiallySignedTransaction by filling in
+    /// Extract the Transaction from a `PartiallySignedTransaction` by filling in
     /// the available signature information in place.
     pub fn extract_tx(&self) -> Result<Transaction, Error> {
         // This should never trigger any error, should be panic here?
@@ -274,32 +284,38 @@ impl PartiallySignedTransaction {
         let mut inputs = vec![];
         let mut outputs = vec![];
 
-        for psetin in self.inputs.iter() {
+        for psetin in &self.inputs {
             let txin = TxIn {
-                previous_output: OutPoint::new(psetin.previous_txid, psetin.previous_output_index),
+                // `previous_outpoint` masks off the pegin/issuance flags, which are
+                // tracked by `is_pegin` and `asset_issuance` instead. Leaving them in
+                // the outpoint would make `SighashCache` hash a different value than
+                // Elements Core does.
+                previous_output: psetin.previous_outpoint(),
                 is_pegin: psetin.is_pegin(),
                 script_sig: psetin.final_script_sig.clone().unwrap_or_default(),
                 sequence: psetin.sequence.unwrap_or(Sequence::MAX),
                 asset_issuance: psetin.asset_issuance(),
                 witness: TxInWitness {
-                    amount_rangeproof: psetin.issuance_value_rangeproof.clone(),
-                    inflation_keys_rangeproof: psetin.issuance_keys_rangeproof.clone(),
+                    amount_rangeproof: psetin.issuance_value_rangeproof
+                        .clone()
+                        .unwrap_or(RangeProof::EMPTY),
+                    inflation_keys_rangeproof: psetin.issuance_keys_rangeproof
+                        .clone()
+                        .unwrap_or(RangeProof::EMPTY),
                     script_witness: psetin
                         .final_script_witness
-                        .as_ref()
-                        .map(|x| x.to_owned())
+                        .clone()
                         .unwrap_or_default(),
                     pegin_witness: psetin
                         .pegin_witness
-                        .as_ref()
-                        .map(|x| x.to_owned())
+                        .clone()
                         .unwrap_or_default(),
                 },
             };
             inputs.push(txin);
         }
 
-        for out in self.outputs.iter() {
+        for out in &self.outputs {
             let txout = TxOut {
                 asset: match (out.asset_comm, out.asset) {
                     (Some(gen), _) => confidential::Asset::Confidential(gen),
@@ -317,15 +333,19 @@ impl PartiallySignedTransaction {
                     .unwrap_or_default(),
                 script_pubkey: out.script_pubkey.clone(),
                 witness: TxOutWitness {
-                    surjection_proof: out.asset_surjection_proof.clone(),
-                    rangeproof: out.value_rangeproof.clone(),
+                    surjection_proof: out.asset_surjection_proof
+                        .clone()
+                        .unwrap_or(SurjectionProof::EMPTY),
+                    rangeproof: out.value_rangeproof
+                        .clone()
+                        .unwrap_or(RangeProof::EMPTY),
                 },
             };
             outputs.push(txout);
         }
         Ok(Transaction {
             version: self.global.tx_data.version,
-            lock_time: locktime.into(),
+            lock_time: locktime,
             input: inputs,
             output: outputs,
         })
@@ -342,11 +362,11 @@ impl PartiallySignedTransaction {
 
         self.global.merge(other.global)?;
 
-        for (self_input, other_input) in self.inputs.iter_mut().zip(other.inputs.into_iter()) {
+        for (self_input, other_input) in self.inputs.iter_mut().zip(other.inputs) {
             self_input.merge(other_input)?;
         }
 
-        for (self_output, other_output) in self.outputs.iter_mut().zip(other.outputs.into_iter()) {
+        for (self_output, other_output) in self.outputs.iter_mut().zip(other.outputs) {
             self_output.merge(other_output)?;
         }
 
@@ -354,6 +374,7 @@ impl PartiallySignedTransaction {
     }
 
     // Common pset blinding checks
+    #[allow(clippy::type_complexity)] // FIXME we probably should actually factor out this return type
     fn blind_checks(
         &self,
         inp_txout_sec: &HashMap<usize, TxOutSecrets>,
@@ -364,6 +385,11 @@ impl PartiallySignedTransaction {
         ),
         PsetBlindError,
     > {
+        for (i, inp) in self.inputs.iter().enumerate() {
+            if inp.has_issuance() && inp.blinded_issuance.unwrap_or(1) == 1 {
+                return Err(PsetBlindError::BlindingIssuanceUnsupported(i));
+            }
+        }
         let mut blind_out_indices = Vec::new();
         for (i, out) in self.outputs.iter().enumerate() {
             if out.blinding_key.is_none() {
@@ -387,8 +413,8 @@ impl PartiallySignedTransaction {
 
         // collect input factors
         let inp_secrets = inp_txout_sec
-            .iter()
-            .map(|(_i, sec)| (sec.value, sec.asset_bf, sec.value_bf))
+            .values()
+            .map(|sec| (sec.value, sec.asset_bf, sec.value_bf))
             .collect::<Vec<_>>();
 
         Ok((inp_secrets, blind_out_indices))
@@ -426,7 +452,7 @@ impl PartiallySignedTransaction {
                         value: 0, // This value really does not matter in surjection proofs
                         value_bf: ValueBlindingFactor::zero(),
                     };
-                    ret.push(SurjectionInput::from_txout_secrets(secrets))
+                    ret.push(SurjectionInput::from_txout_secrets(secrets));
                 }
                 if inp.issuance_inflation_keys.is_some()
                     || inp.issuance_inflation_keys_comm.is_some()
@@ -437,7 +463,7 @@ impl PartiallySignedTransaction {
                         value: 0, // This value really does not matter in surjection proofs
                         value_bf: ValueBlindingFactor::zero(),
                     };
-                    ret.push(SurjectionInput::from_txout_secrets(secrets))
+                    ret.push(SurjectionInput::from_txout_secrets(secrets));
                 }
             }
         }
@@ -448,8 +474,8 @@ impl PartiallySignedTransaction {
     /// should call the `blind_last` function which balances the blinding factors
     /// `inp_secrets` and must be consistent by [`Output`] `blinder_index` field
     /// For each output that is to be blinded, the following must be true
-    /// 1. The blinder_index must be set in pset output field
-    /// 2. the corresponding inp_secrets\[out.blinder_index\] must be present
+    /// 1. The `blinder_index` must be set in pset output field
+    /// 2. the corresponding `inp_secrets`\[`out.blinder_index`\] must be present
     ///
     /// Issuances and re-issuance inputs are not blinded.
     /// # Parameters
@@ -463,20 +489,20 @@ impl PartiallySignedTransaction {
         rng: &mut R,
         secp: &secp256k1_zkp::Secp256k1<C>,
         inp_txout_sec: &HashMap<usize, TxOutSecrets>,
-    ) -> Result<Vec<(AssetBlindingFactor, ValueBlindingFactor)>, PsetBlindError> {
+    ) -> Result<BTreeMap<CtLocation, (AssetBlindingFactor, ValueBlindingFactor, SecretKey)>, PsetBlindError> {
         let (inp_secrets, outs_to_blind) = self.blind_checks(inp_txout_sec)?;
 
+        let mut ret = BTreeMap::new(); // return all the random values used
         if outs_to_blind.is_empty() {
             // Return empty values if no outputs are marked for blinding
-            return Ok(Vec::new());
+            return Ok(ret);
         }
         // Blind each output as non-last and save the secrets
         let surject_inputs = self.surjection_inputs(inp_txout_sec)?;
         let mut out_secrets = vec![];
-        let mut ret = vec![]; // return all the random values used
         for i in outs_to_blind {
             let txout = self.outputs[i].to_txout();
-            let (txout, abf, vbf, _) = txout
+            let (txout, abf, vbf, ephemeral_sk) = txout
                 .to_non_last_confidential(
                     rng,
                     secp,
@@ -494,8 +520,8 @@ impl PartiallySignedTransaction {
 
             // mutate the pset
             {
-                self.outputs[i].value_rangeproof = txout.witness.rangeproof;
-                self.outputs[i].asset_surjection_proof = txout.witness.surjection_proof;
+                self.outputs[i].value_rangeproof = Some(txout.witness.rangeproof);
+                self.outputs[i].asset_surjection_proof = Some(txout.witness.surjection_proof);
                 self.outputs[i].amount_comm = txout.value.commitment();
                 self.outputs[i].asset_comm = txout.asset.commitment();
                 self.outputs[i].ecdh_pubkey =
@@ -506,10 +532,10 @@ impl PartiallySignedTransaction {
                 let asset_id = self.outputs[i]
                     .asset
                     .ok_or(PsetBlindError::MustHaveExplicitTxOut(i))?;
-                self.outputs[i].blind_asset_proof = Some(Box::new(
+                self.outputs[i].blind_asset_proof = Some(
                     SurjectionProof::blind_asset_proof(rng, secp, asset_id, abf)
                         .map_err(|e| PsetBlindError::BlindingProofsCreationError(i, e))?,
-                ));
+                );
 
                 let asset_gen = self.outputs[i]
                     .asset_comm
@@ -517,13 +543,14 @@ impl PartiallySignedTransaction {
                 let value_comm = self.outputs[i]
                     .amount_comm
                     .expect("Blinding proof successful");
-                self.outputs[i].blind_value_proof = Some(Box::new(
+                self.outputs[i].blind_value_proof = Some(
                     RangeProof::blind_value_proof(rng, secp, value, value_comm, asset_gen, vbf)
                         .map_err(|e| PsetBlindError::BlindingProofsCreationError(i, e))?,
-                ));
+                );
             }
             // return blinding factors used
-            ret.push((abf, vbf));
+            let location = CtLocation{ input_index: i, ty: CtLocationType::Input};
+            ret.insert(location, (abf, vbf, ephemeral_sk));
         }
 
         // safe to unwrap because we have checked that there is atleast one output to blind
@@ -544,7 +571,7 @@ impl PartiallySignedTransaction {
         // Push the scalar
         // BUG in pset
         // Bug in Pset, scalars can be the same value, but there is no place
-        // in pset to place them as it would break the uniqueness constriant.
+        // in pset to place them as it would break the uniqueness constraint.
         self.global.scalars.push(vbf2.into_inner());
         Ok(ret)
     }
@@ -554,7 +581,7 @@ impl PartiallySignedTransaction {
     /// This function balances the blinding factors with partial information about
     /// blinding inputs and scalars from [`Global`] scalars field.
     /// `inp_secrets` and `out_secrets` must be consistent by [`Output`] `blinder_index` field
-    /// For each output, the corresponding inp_secrets\[out.blinder_index\] must be present
+    /// For each output, the corresponding `inp_secrets`\[`out.blinder_index`\] must be present
     /// # Parameters
     ///
     /// * `inp_secrets`: [`TxOutSecrets`] corresponding to owned inputs. Use [`None`] for non-owned outputs
@@ -564,9 +591,10 @@ impl PartiallySignedTransaction {
         rng: &mut R,
         secp: &secp256k1_zkp::Secp256k1<C>,
         inp_txout_sec: &HashMap<usize, TxOutSecrets>,
-    ) -> Result<(), PsetBlindError> {
+    ) -> Result<BTreeMap<CtLocation, (AssetBlindingFactor, ValueBlindingFactor, SecretKey)>, PsetBlindError> {
         let (mut inp_secrets, mut outs_to_blind) = self.blind_checks(inp_txout_sec)?;
 
+        let mut ret = BTreeMap::new();
         if outs_to_blind.is_empty() {
             // Atleast one output must be marked for blinding for pset blind_last
             return Err(PsetBlindError::AtleastOneOutputBlind);
@@ -579,7 +607,7 @@ impl PartiallySignedTransaction {
             let ind = self.outputs[last_out_index].blinder_index;
             self.outputs[last_out_index].blinder_index = None;
             // Blind normally without the last index
-            self.blind_non_last(rng, secp, inp_txout_sec)?;
+            ret = self.blind_non_last(rng, secp, inp_txout_sec)?;
             // Restore who blinded the last output
             self.outputs[last_out_index].blinder_index = ind;
             // inp_secrets contributed to self.global.scalars, unset it so we don't count them
@@ -619,7 +647,7 @@ impl PartiallySignedTransaction {
             ValueBlindingFactor::last(secp, value, out_abf, &inp_secrets, &exp_out_secrets);
 
         // Add all the scalars
-        for value_diff in self.global.scalars.iter() {
+        for value_diff in &self.global.scalars {
             final_vbf += ValueBlindingFactor(*value_diff);
         }
 
@@ -628,10 +656,7 @@ impl PartiallySignedTransaction {
             .ok_or(PsetBlindError::MustHaveExplicitTxOut(last_out_index))?;
         let ephemeral_sk = SecretKey::new(rng);
         let spk = &self.outputs[last_out_index].script_pubkey;
-        let msg = RangeProofMessage {
-            asset: asset_id,
-            bf: out_abf,
-        };
+        let msg = RangeProofMessage::new(asset_id, out_abf);
         let blind_res = exp_value.blind(
             secp,
             final_vbf,
@@ -642,11 +667,13 @@ impl PartiallySignedTransaction {
         );
         let (value_commitment, nonce, rangeproof) =
             blind_res.map_err(|e| PsetBlindError::ConfidentialTxOutError(last_out_index, e))?;
+        let location = CtLocation{ input_index: last_out_index, ty: CtLocationType::Input};
+        ret.insert(location, (out_abf, final_vbf, ephemeral_sk));
 
         // mutate the pset
         {
-            self.outputs[last_out_index].value_rangeproof = Some(Box::new(rangeproof));
-            self.outputs[last_out_index].asset_surjection_proof = Some(Box::new(surjection_proof));
+            self.outputs[last_out_index].value_rangeproof = Some(rangeproof);
+            self.outputs[last_out_index].asset_surjection_proof = Some(surjection_proof);
             self.outputs[last_out_index].amount_comm = value_commitment.commitment();
             self.outputs[last_out_index].asset_comm = out_asset_commitment.commitment();
             self.outputs[last_out_index].ecdh_pubkey =
@@ -657,10 +684,10 @@ impl PartiallySignedTransaction {
             let asset_id = self.outputs[last_out_index]
                 .asset
                 .ok_or(PsetBlindError::MustHaveExplicitTxOut(last_out_index))?;
-            self.outputs[last_out_index].blind_asset_proof = Some(Box::new(
+            self.outputs[last_out_index].blind_asset_proof = Some(
                 SurjectionProof::blind_asset_proof(rng, secp, asset_id, out_abf)
                     .map_err(|e| PsetBlindError::BlindingProofsCreationError(last_out_index, e))?,
-            ));
+            );
 
             let asset_gen = self.outputs[last_out_index]
                 .asset_comm
@@ -668,14 +695,14 @@ impl PartiallySignedTransaction {
             let value_comm = self.outputs[last_out_index]
                 .amount_comm
                 .expect("Blinding proof successful");
-            self.outputs[last_out_index].blind_value_proof = Some(Box::new(
+            self.outputs[last_out_index].blind_value_proof = Some(
                 RangeProof::blind_value_proof(rng, secp, value, value_comm, asset_gen, final_vbf)
                     .map_err(|e| PsetBlindError::BlindingProofsCreationError(last_out_index, e))?,
-            ));
+            );
 
-            self.global.scalars.clear()
+            self.global.scalars.clear();
         }
-        Ok(())
+        Ok(ret)
     }
 }
 
@@ -719,7 +746,7 @@ impl Decodable for PartiallySignedTransaction {
 
             // Maximum pset input size supported
             if inputs_len > 10_000 {
-                return Err(Error::TooLargePset)?;
+                return Err(Error::TooLargePset.into());
             }
 
             let mut inputs: Vec<Input> = Vec::with_capacity(inputs_len);
@@ -736,7 +763,7 @@ impl Decodable for PartiallySignedTransaction {
 
             // Maximum pset input size supported
             if outputs_len > 10_000 {
-                return Err(Error::TooLargePset)?;
+                return Err(Error::TooLargePset.into());
             }
 
             let mut outputs: Vec<Output> = Vec::with_capacity(outputs_len);
@@ -748,11 +775,7 @@ impl Decodable for PartiallySignedTransaction {
             outputs
         };
 
-        let pset = PartiallySignedTransaction {
-            global: global,
-            inputs: inputs,
-            outputs: outputs,
-        };
+        let pset = PartiallySignedTransaction { global, inputs, outputs };
         pset.sanity_check()?;
         Ok(pset)
     }
@@ -761,23 +784,25 @@ impl Decodable for PartiallySignedTransaction {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bitcoin::hashes::hex::{FromHex, ToHex};
+    use crate::OutPoint;
+    use hex::DisplayHex as _;
 
+    #[track_caller]
     fn tx_pset_rtt(tx_hex: &str) {
         let tx: Transaction =
-            encode::deserialize(&Vec::<u8>::from_hex(tx_hex).unwrap()[..]).unwrap();
+            encode::deserialize(&hex::decode_to_vec(tx_hex).unwrap()).unwrap();
         let pset = PartiallySignedTransaction::from_tx(tx);
         let rtt_tx_hex = encode::serialize_hex(&pset.extract_tx().unwrap());
         assert_eq!(tx_hex, rtt_tx_hex);
         let pset_rtt_hex = encode::serialize_hex(&pset);
         let pset2: PartiallySignedTransaction =
-            encode::deserialize(&Vec::<u8>::from_hex(&pset_rtt_hex).unwrap()[..]).unwrap();
+            encode::deserialize(&hex::decode_to_vec(&pset_rtt_hex).unwrap()).unwrap();
         assert_eq!(pset, pset2);
     }
 
     fn pset_rtt(pset_hex: &str) {
         let pset: PartiallySignedTransaction =
-            encode::deserialize(&Vec::<u8>::from_hex(pset_hex).unwrap()[..]).unwrap();
+            encode::deserialize(&hex::decode_to_vec(pset_hex).unwrap()[..]).unwrap();
 
         assert_eq!(encode::serialize_hex(&pset), pset_hex);
     }
@@ -807,14 +832,15 @@ mod tests {
         use serde_json;
         use std::str::FromStr;
 
+        const PSET_HEX: &str = "70736574ff01020402000000010401010105010201fb04020000000001017a0bb9325c276764451bbc2eb82a4c8c4bb6f4007ba803e5a5ba72d0cd7c09848e1a091622d935953bf06e0b7393239c68c6f810a00fe19d11c6ae343cffd3037077da02535fe4ad0fcd675cd0f62bf73b60a554dc1569b80f1f76a2bbfc9f00d439bf4b160014d2cbec8783bd01c9f178348b08500a830a89a7f9010e20805131ba6b37165c026eed9325ac56059ba872fd569e3ed462734098688b4770010f0400000000000103088c83b50d0000000007fc04707365740220230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20104220020e5793ad956ee91ebf3543b37d110701118ed4078ffa0d477eacb8885e486ad8507fc047073657406210212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea07fc047073657408040000000000010308f40100000000000007fc04707365740220230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b201040000";
+
         // Initially secp context and rng global state
         let secp = secp256k1_zkp::Secp256k1::new();
         #[allow(deprecated)]
         let mut rng = rand::rngs::StdRng::seed_from_u64(0);
 
-        let pset_hex = "70736574ff01020402000000010401010105010201fb04020000000001017a0bb9325c276764451bbc2eb82a4c8c4bb6f4007ba803e5a5ba72d0cd7c09848e1a091622d935953bf06e0b7393239c68c6f810a00fe19d11c6ae343cffd3037077da02535fe4ad0fcd675cd0f62bf73b60a554dc1569b80f1f76a2bbfc9f00d439bf4b160014d2cbec8783bd01c9f178348b08500a830a89a7f9010e20805131ba6b37165c026eed9325ac56059ba872fd569e3ed462734098688b4770010f0400000000000103088c83b50d0000000007fc04707365740220230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b20104220020e5793ad956ee91ebf3543b37d110701118ed4078ffa0d477eacb8885e486ad8507fc047073657406210212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea07fc047073657408040000000000010308f40100000000000007fc04707365740220230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b201040000";
         let mut pset: PartiallySignedTransaction =
-            encode::deserialize(&Vec::<u8>::from_hex(&pset_hex).unwrap()[..]).unwrap();
+            encode::deserialize(&hex::hex!(PSET_HEX)).unwrap();
 
         let btc_txout_secrets_str = r#"
         {
@@ -825,15 +851,15 @@ mod tests {
         }"#;
         let v: serde_json::Value = serde_json::from_str(btc_txout_secrets_str).unwrap();
         let btc_txout_secrets = TxOutSecrets {
-            asset_bf: AssetBlindingFactor::from_str(&v["assetblinder"].as_str().unwrap()).unwrap(),
-            value_bf: ValueBlindingFactor::from_str(&v["amountblinder"].as_str().unwrap()).unwrap(),
+            asset_bf: AssetBlindingFactor::from_str(v["assetblinder"].as_str().unwrap()).unwrap(),
+            value_bf: ValueBlindingFactor::from_str(v["amountblinder"].as_str().unwrap()).unwrap(),
             value: bitcoin::Amount::from_str_in(
-                &v["amount"].as_str().unwrap(),
+                v["amount"].as_str().unwrap(),
                 bitcoin::Denomination::Bitcoin,
             )
             .unwrap()
             .to_sat(),
-            asset: AssetId::from_hex(&v["asset"].as_str().unwrap()).unwrap(),
+            asset: AssetId::from_str(v["asset"].as_str().unwrap()).unwrap(),
         };
 
         let mut inp_txout_sec = HashMap::new();
@@ -849,64 +875,55 @@ mod tests {
     fn basic_pset() {
         // Invalid psets
         // Check Global mandatory field
-        let pset_str = "70736574ff010401000105010001fb040200000000";
         let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
+            &hex::hex!("70736574ff010401000105010001fb040200000000"),
         );
         pset.expect_err("Missing tx version");
 
         // Check input mandatory field
-        let pset_str = "70736574ff010204020000000104010001fb040200000000";
         let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
+            &hex::hex!("70736574ff010204020000000104010001fb040200000000"),
         );
         pset.expect_err("Missing inp count");
 
-        let pset_str = "70736574ff010204020000000105010001fb040200000000";
         let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
+            &hex::hex!("70736574ff010204020000000105010001fb040200000000"),
         );
         pset.expect_err("Missing out count");
 
-        let pset_str = "70736574ff01020402000000010401000105010000";
         let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
+            &hex::hex!("70736574ff01020402000000010401000105010000"),
         );
         pset.expect_err("Missing pset version");
         // Check inp/out count mismatch
-        let pset_str = "70736574ff01020402000000010401000105010001fb04020000000001017a0ad92644e9bf6cb8d0856a8ca713c8a212d3a62142e85454b7865217890e52ec3108a469a9811ec1c1df7a98dbc3a7f71860293e98c6fad8a7ef6828344e9172547302217d344513f0a5ed1a60ebeba01460c505ad63d95b3542fb303aca8f9382777d160014bd5c31aaea2ddc585f317ee589bc6800bc95e7e6010e208965573f41392a88d8bb106cf13a7bdc69f1ab914cd5e8de11235467b514e5a9010f040100000000";
-        let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
-        );
+        let pset = encode::deserialize::<PartiallySignedTransaction>(&hex::hex!(
+            "70736574ff01020402000000010401000105010001fb04020000000001017a0ad92644e9bf6cb8d0856a8ca713c8a212d3a62142e85454b7865217890e52ec3108a469a9811ec1c1df7a98dbc3a7f71860293e98c6fad8a7ef6828344e9172547302217d344513f0a5ed1a60ebeba01460c505ad63d95b3542fb303aca8f9382777d160014bd5c31aaea2ddc585f317ee589bc6800bc95e7e6010e208965573f41392a88d8bb106cf13a7bdc69f1ab914cd5e8de11235467b514e5a9010f040100000000"
+        ));
         pset.expect_err("Input count mismatch");
 
         // input mandatory field
-        let pset_str = "70736574ff01020402000000010401010105010001fb04020000000001017a0ad92644e9bf6cb8d0856a8ca713c8a212d3a62142e85454b7865217890e52ec3108a469a9811ec1c1df7a98dbc3a7f71860293e98c6fad8a7ef6828344e9172547302217d344513f0a5ed1a60ebeba01460c505ad63d95b3542fb303aca8f9382777d160014bd5c31aaea2ddc585f317ee589bc6800bc95e7e601010f040100000000";
-        let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
-        );
+        let pset = encode::deserialize::<PartiallySignedTransaction>(&hex::hex!(
+            "70736574ff01020402000000010401010105010001fb04020000000001017a0ad92644e9bf6cb8d0856a8ca713c8a212d3a62142e85454b7865217890e52ec3108a469a9811ec1c1df7a98dbc3a7f71860293e98c6fad8a7ef6828344e9172547302217d344513f0a5ed1a60ebeba01460c505ad63d95b3542fb303aca8f9382777d160014bd5c31aaea2ddc585f317ee589bc6800bc95e7e601010f040100000000"
+        ));
         pset.expect_err("Input mandatory field prevtxid");
 
         // output mandatory amount field
-        let pset_str = "70736574ff01020402000000010401000105010101fb04020000000007fc04707365740220010101010101010101010101010101010101010101010101010101010101010101040000";
-        let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
-        );
+        let pset = encode::deserialize::<PartiallySignedTransaction>(&hex::hex!(
+            "70736574ff01020402000000010401000105010101fb04020000000007fc04707365740220010101010101010101010101010101010101010101010101010101010101010101040000"
+        ));
         pset.expect_err("Output non-mandatory field");
 
-        let pset_str = "70736574ff01020402000000010401000105010101fb040200000000010308170000000000000007fc0470736574022009090909090909090909090909090909090909090909090909090909090909090100";
-        let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
-        );
+        let pset = encode::deserialize::<PartiallySignedTransaction>(&hex::hex!(
+            "70736574ff01020402000000010401000105010101fb040200000000010308170000000000000007fc0470736574022009090909090909090909090909090909090909090909090909090909090909090100"
+        ));
         pset.expect_err("Output mandatory field script pubkey");
 
         // Valid Psets
 
         // Check both possible conf/explicit values are allowed for pset
-        let pset_str = "70736574ff01020402000000010401000105010101fb040200000000010308170000000000000007fc0470736574012109090909090909090909090909090909090909090909090909090909090909090907fc04707365740220090909090909090909090909090909090909090909090909090909090909090901040000";
-        let pset = encode::deserialize::<PartiallySignedTransaction>(
-            &Vec::<u8>::from_hex(pset_str).unwrap()[..],
-        );
+        let pset = encode::deserialize::<PartiallySignedTransaction>(&hex::hex!(
+            "70736574ff01020402000000010401000105010101fb040200000000010308170000000000000007fc0470736574012109090909090909090909090909090909090909090909090909090909090909090907fc04707365740220090909090909090909090909090909090909090909090909090909090909090901040000"
+        ));
         pset.expect("Both conf/explicit value are allowed be present in map");
 
         // Commented code for quick test vector generation
@@ -936,19 +953,151 @@ mod tests {
         // println!("{}", encode::serialize_hex(&pset));
     }
 
+    // https://github.com/ElementsProject/rust-elements/issues/292
+    //
+    // The pegin/issuance flags belong in `TxIn::is_pegin`/`TxIn::asset_issuance`,
+    // not in the outpoint. If `extract_tx` left them in the vout, `SighashCache`
+    // would commit to a different outpoint than Elements Core does and the
+    // resulting signatures would be rejected.
+    #[test]
+    fn extract_tx_masks_pegin_flag_from_outpoint() {
+        use crate::sighash::SighashCache;
+        use crate::{EcdsaSighashType, Script};
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_pegin.hex"));
+        let txin = &tx.input[0];
+        assert!(txin.is_pegin());
+        assert_eq!(txin.previous_output.vout & ((1 << 30) | (1 << 31)), 0);
+
+        let pset = PartiallySignedTransaction::from_tx(tx.clone());
+        // The PSET representation carries the flag in the index...
+        assert_eq!(
+            pset.inputs()[0].previous_output_index,
+            txin.previous_output.vout | (1 << 30),
+        );
+
+        // ...but the extracted transaction must not.
+        let extracted = pset.extract_tx().unwrap();
+        let extracted_txin = &extracted.input[0];
+        assert!(extracted_txin.is_pegin);
+        assert_eq!(extracted_txin.previous_output, txin.previous_output);
+        assert_eq!(extracted, tx);
+        assert_eq!(extracted.txid(), tx.txid());
+
+        // And the flag bits really are sighash-relevant: had they been left in the
+        // vout, the segwit v0 sighash (and hence the signature) would differ.
+        let script_code = Script::from_hex_no_prefix(
+            "76a914d2bcde17e7744f6377466ca1bd35d212954674c888ac",
+        ).unwrap();
+        let value = confidential::Value::Explicit(100_000);
+        let sighash = |tx: &Transaction| {
+            SighashCache::new(tx).segwitv0_sighash(
+                0,
+                &script_code,
+                value,
+                EcdsaSighashType::All,
+            )
+        };
+        let mut flagged = extracted.clone();
+        flagged.input[0].previous_output.vout |= 1 << 30;
+        assert_ne!(sighash(&flagged), sighash(&extracted));
+    }
+
     #[test]
     fn pset_from_elements() {
         let pset_str = include_str!("../../tests/data/pset_swap_tutorial.hex");
 
-        let bytes = Vec::<u8>::from_hex(pset_str).unwrap();
+        let bytes = hex::decode_to_vec(pset_str).unwrap();
         let pset = encode::deserialize::<PartiallySignedTransaction>(&bytes).unwrap();
 
-        assert_eq!(pset_str.len(), encode::serialize(&pset).to_hex().len());
-        let back_hex = encode::serialize(&pset).to_hex();
+        assert_eq!(pset_str.len(), encode::serialize(&pset).to_lower_hex_string().len());
+        let back_hex = encode::serialize(&pset).to_lower_hex_string();
         //assert_eq!(pset_str, &back_hex);  //TODO this fails, field ordering?
 
-        let bytes = Vec::<u8>::from_hex(&back_hex).unwrap();
+        let bytes = hex::decode_to_vec(&back_hex).unwrap();
         let pset = encode::deserialize::<PartiallySignedTransaction>(&bytes).unwrap();
-        assert_eq!(&back_hex, &encode::serialize(&pset).to_hex());
+        assert_eq!(&back_hex, &encode::serialize(&pset).to_lower_hex_string());
+    }
+
+    #[test]
+    fn pset_remove_in_out() {
+        let pset_str = include_str!("../../tests/data/pset_swap_tutorial.hex");
+
+        let bytes = hex::decode_to_vec(pset_str).unwrap();
+        let mut pset = encode::deserialize::<PartiallySignedTransaction>(&bytes).unwrap();
+
+        let n_inputs = pset.n_inputs();
+        let n_outputs = pset.n_outputs();
+        pset.remove_input(n_inputs - 1).unwrap();
+        pset.remove_output(n_outputs - 1).unwrap();
+        assert_eq!(pset.n_inputs(), n_inputs - 1);
+        assert_eq!(pset.n_outputs(), n_outputs - 1);
+    }
+
+    #[test]
+    fn pset_issuance() {
+        use std::str::FromStr;
+        use rand::{self, SeedableRng};
+        let secp = secp256k1_zkp::Secp256k1::new();
+        #[allow(deprecated)]
+        let mut rng = rand::rngs::StdRng::seed_from_u64(0);
+
+        let policy = crate::AssetId::from_str("5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225").unwrap();
+        let pk = bitcoin::key::PublicKey::from_str("020202020202020202020202020202020202020202020202020202020202020202").unwrap();
+        let script = crate::Script::from_hex_no_prefix("0014d2bcde17e7744f6377466ca1bd35d212954674c8").unwrap();
+        let sats_in = 10000;
+        let sats_fee = 1000;
+        let btc_txout_secrets = TxOutSecrets {
+            asset_bf: AssetBlindingFactor::from_str("1111111111111111111111111111111111111111111111111111111111111111").unwrap(),
+            value_bf: ValueBlindingFactor::from_str("2222222222222222222222222222222222222222222222222222222222222222").unwrap(),
+            value: sats_in,
+            asset: policy,
+        };
+        let previous_output = TxOut::default();  // Does not match btc_txout_secrets
+        let prevout = OutPoint::default();
+        let sats_asset = 10;
+        let sats_token = 1;
+
+        let mut pset = PartiallySignedTransaction::new_v2();
+        let mut input = Input::from_prevout(prevout);
+        input.witness_utxo = Some(previous_output);
+        input.issuance_value_amount = Some(sats_asset);
+        input.issuance_inflation_keys = Some(sats_token);
+        let (asset, token) = input.issuance_ids();
+        pset.add_input(input);
+
+        // Add asset
+        let mut output = Output::new_explicit(script.clone(), sats_asset, asset, Some(pk));
+        output.blinder_index = Some(0);
+        pset.add_output(output);
+        // Add token
+        let mut output = Output::new_explicit(script.clone(), sats_token, token, Some(pk));
+        output.blinder_index = Some(0);
+        pset.add_output(output);
+        // Add L-BTC
+        let mut output = Output::new_explicit(script.clone(), sats_in - sats_fee, policy, Some(pk));
+        output.blinder_index = Some(0);
+        pset.add_output(output);
+        // Add fee
+        let output = Output::new_explicit(crate::Script::new(), sats_fee, policy, None);
+        pset.add_output(output);
+
+        let mut inp_txout_sec = HashMap::new();
+        inp_txout_sec.insert(0, btc_txout_secrets);
+
+        let err = pset.blind_last(&mut rng, &secp, &inp_txout_sec).unwrap_err();
+        assert_eq!(err, PsetBlindError::BlindingIssuanceUnsupported(0));
+
+        let input = &mut pset.inputs_mut()[0];
+        input.blinded_issuance = Some(0x01);
+        let err = pset.blind_last(&mut rng, &secp, &inp_txout_sec).unwrap_err();
+        assert_eq!(err, PsetBlindError::BlindingIssuanceUnsupported(0));
+
+        let input = &mut pset.inputs_mut()[0];
+        input.blinded_issuance = Some(0x00);
+        pset.blind_last(&mut rng, &secp, &inp_txout_sec).unwrap();
+        let pset_bytes = encode::serialize(&pset);
+        let pset_des = encode::deserialize(&pset_bytes).unwrap();
+        assert_eq!(pset, pset_des);
     }
 }
diff --git a/src/pset/raw.rs b/src/pset/raw.rs
index a442d72d..55b8169e 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -15,24 +15,19 @@
 //! # Raw PSET Key-Value Pairs
 //!
 //! Raw PSET key-value pairs as defined at
-//! https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki.
+//! <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>.
 
 use std::{fmt, io};
 
 use super::Error;
-use crate::encode::{
-    self, deserialize, serialize, Decodable, Encodable, ReadExt, WriteExt, MAX_VEC_SIZE,
-};
-use crate::hashes::hex;
-use crate::VarInt;
+use crate::encode::{self, deserialize, serialize, Decodable, Encodable, VarInt, MAX_VEC_SIZE};
+use hex::DisplayHex as _;
 /// A PSET key in its raw byte form.
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Key {
     /// The type of this PSET key.
     pub type_value: u8,
     /// The key itself in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key: Vec<u8>,
 }
 
@@ -41,8 +36,8 @@ impl Key {
     pub fn from_pset_key(subtype: ProprietaryType, key: Vec<u8>) -> Self {
         let pset_prop_key = ProprietaryKey {
             prefix: "pset".as_bytes().to_vec(),
-            subtype: subtype,
-            key: key,
+            subtype,
+            key,
         };
         pset_prop_key.to_key()
     }
@@ -50,12 +45,10 @@ impl Key {
 
 /// A PSET key-value pair in its raw byte form.
 #[derive(Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Pair {
     /// The key of this key-value pair.
     pub key: Key,
     /// The value of this key-value pair in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub value: Vec<u8>,
 }
 
@@ -64,7 +57,6 @@ pub type ProprietaryType = u8;
 
 /// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
 /// structure according to BIP 174.
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct ProprietaryKey<Subtype = ProprietaryType>
 where
@@ -72,12 +64,10 @@ where
 {
     /// 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>,
 }
 
@@ -94,16 +84,15 @@ impl ProprietaryKey {
         Self {
             // TODO: precompute this
             prefix: String::from("pset").into_bytes(),
-            subtype: subtype,
-            key: key,
+            subtype,
+            key,
         }
     }
 }
 
 impl fmt::Display for Key {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "type: {:#x}, key: ", self.type_value)?;
-        hex::format_hex(&self.key[..], f)
+        write!(f, "type: {:#x}, key: {}", self.type_value, self.key.as_hex())
     }
 }
 
@@ -131,10 +120,7 @@ impl Decodable for Key {
             key.push(Decodable::consensus_decode(&mut d)?);
         }
 
-        Ok(Key {
-            type_value: type_value,
-            key: key,
-        })
+        Ok(Key { type_value, key })
     }
 }
 
@@ -146,7 +132,7 @@ impl Encodable for Key {
         len += self.type_value.consensus_encode(&mut s)?;
 
         for key in &self.key {
-            len += key.consensus_encode(&mut s)?
+            len += key.consensus_encode(&mut s)?;
         }
 
         Ok(len)
@@ -173,7 +159,7 @@ impl<Subtype> Encodable for ProprietaryKey<Subtype>
 where
     Subtype: Copy + From<u8> + Into<u8>,
 {
-    fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
+    fn consensus_encode<W: crate::WriteExt>(&self, mut e: W) -> Result<usize, encode::Error> {
         let mut len = self.prefix.consensus_encode(&mut e)? + 1;
         e.emit_u8(self.subtype.into())?;
         len += e.write(&self.key)?;
@@ -189,7 +175,7 @@ where
         let prefix = Vec::<u8>::consensus_decode(&mut d)?;
         let mut key = vec![];
 
-        let subtype = Subtype::from(d.read_u8()?);
+        let subtype = Subtype::from(u8::consensus_decode(&mut d)?);
         d.read_to_end(&mut key)?;
 
         Ok(ProprietaryKey {
@@ -204,9 +190,9 @@ impl<Subtype> ProprietaryKey<Subtype>
 where
     Subtype: Copy + From<u8> + Into<u8>,
 {
-    /// Constructs [ProprietaryKey] from [Key]; returns
-    /// [Error::InvalidProprietaryKey] if `key` do not starts with 0xFC byte
-    pub fn from_key(key: Key) -> Result<Self, Error> {
+    /// Constructs [`ProprietaryKey`] from [Key]; returns
+    /// [`Error::InvalidProprietaryKey`] if `key` do not starts with 0xFC byte
+    pub fn from_key(key: &Key) -> Result<Self, Error> {
         if key.type_value != 0xFC {
             return Err(Error::InvalidProprietaryKey);
         }
diff --git a/src/pset/serialize.rs b/src/pset/serialize.rs
index 19ed2305..cf39eaca 100644
--- a/src/pset/serialize.rs
+++ b/src/pset/serialize.rs
@@ -19,20 +19,23 @@
 
 use std::io;
 
-use crate::confidential;
-use crate::encode::{self, deserialize, deserialize_partial, serialize, Decodable, Encodable};
+use crate::confidential::{self, AssetBlindingFactor};
+use crate::encode::{
+    self, deserialize, deserialize_partial, serialize, Decodable, Encodable, VarInt,
+};
 use crate::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-use crate::{AssetId, BlockHash, Script, Transaction, TxOut, Txid};
-use bitcoin::hashes::hex::ToHex;
-use bitcoin::util::bip32::{ChildNumber, Fingerprint, KeySource};
-use bitcoin::{self, PublicKey, VarInt};
-use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
+use crate::{AssetBlindingNonce, AssetEntropy, AssetId, BlockHash, RangeProof, Script, SurjectionProof, Transaction, TxOut, Txid};
+use bitcoin;
+use bitcoin::bip32::{ChildNumber, Fingerprint, KeySource};
+use bitcoin::{key::XOnlyPublicKey, PublicKey};
+use internals::slice::SliceExt;
+use secp256k1_zkp;
 
 use super::map::{PsbtSighashType, TapTree};
 use crate::schnorr;
-use crate::taproot::{ControlBlock, LeafVersion, TapBranchHash, TapLeafHash};
+use crate::taproot::{ControlBlock, LeafVersion, TapLeafHash, TapNodeHash};
 
-use crate::sighash::SchnorrSigHashType;
+use crate::sighash::SchnorrSighashType;
 use crate::taproot::TaprootBuilder;
 
 /// A trait for serializing a value as raw data for insertion into PSET
@@ -50,22 +53,25 @@ pub trait Deserialize: Sized {
 
 /// Encode an object into a hex-encoded string
 pub fn serialize_hex<T: Serialize + ?Sized>(data: &T) -> String {
-    Serialize::serialize(data)[..].to_hex()
+    use hex::DisplayHex as _;
+    Serialize::serialize(data)[..].to_lower_hex_string()
 }
 
 impl_pset_de_serialize!(Transaction);
 impl_pset_de_serialize!(TxOut);
+impl_pset_de_serialize!(AssetBlindingNonce);
+impl_pset_de_serialize!(AssetEntropy);
 impl_pset_de_serialize!(AssetId);
 impl_pset_de_serialize!(u8);
 impl_pset_de_serialize!(u32);
 impl_pset_de_serialize!(u64);
-impl_pset_de_serialize!(crate::PackedLockTime);
+impl_pset_de_serialize!(crate::LockTime);
 impl_pset_de_serialize!(crate::Sequence);
 impl_pset_de_serialize!(crate::locktime::Height);
 impl_pset_de_serialize!(crate::locktime::Time);
 impl_pset_de_serialize!([u8; 32]);
-impl_pset_de_serialize!(VarInt);
-impl_pset_de_serialize!(Vec<Vec<u8>>); // scriptWitness
+impl_pset_de_serialize!(crate::PeginWitness); // peginWitness
+impl_pset_de_serialize!(crate::Witness); // scriptWitness
 impl_pset_hash_de_serialize!(Txid);
 impl_pset_hash_de_serialize!(ripemd160::Hash);
 impl_pset_hash_de_serialize!(sha256::Hash);
@@ -73,24 +79,48 @@ impl_pset_hash_de_serialize!(hash160::Hash);
 impl_pset_hash_de_serialize!(sha256d::Hash);
 impl_pset_hash_de_serialize!(BlockHash);
 impl_pset_hash_de_serialize!(TapLeafHash);
-impl_pset_hash_de_serialize!(TapBranchHash);
+impl_pset_hash_de_serialize!(TapNodeHash);
 
 // required for pegin bitcoin::Transactions
-impl_pset_de_serialize!(bitcoin::Transaction);
+impl Deserialize for bitcoin::Transaction {
+    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
+        Ok(bitcoin::consensus::encode::deserialize(bytes)?)
+    }
+}
+impl Serialize for bitcoin::Transaction {
+    fn serialize(&self) -> Vec<u8> {
+        bitcoin::consensus::encode::serialize(self)
+    }
+}
 
 // taproot
 impl_pset_de_serialize!(Vec<TapLeafHash>);
 
-impl Serialize for Tweak {
+impl Serialize for VarInt {
+    fn serialize(&self) -> Vec<u8> {
+        let mut v = vec![];
+        self.consensus_encode(&mut v).expect("vec don't errors");
+        v
+    }
+}
+
+impl Deserialize for VarInt {
+    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
+        VarInt::consensus_decode(bytes)
+    }
+}
+
+impl Serialize for AssetBlindingFactor {
     fn serialize(&self) -> Vec<u8> {
-        encode::serialize(self.as_ref())
+        encode::serialize(self.into_inner().as_ref())
     }
 }
 
-impl Deserialize for Tweak {
+impl Deserialize for AssetBlindingFactor {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        let x = deserialize::<[u8; 32]>(&bytes)?;
-        Tweak::from_slice(&x).map_err(|_| encode::Error::ParseFailed("invalid Tweak"))
+        let x = deserialize::<[u8; 32]>(bytes)?;
+        AssetBlindingFactor::from_slice(&x)
+            .map_err(|_| encode::Error::ParseFailed("invalid AssetBlindingFactor"))
     }
 }
 
@@ -122,12 +152,12 @@ impl Deserialize for PublicKey {
 
 impl Serialize for KeySource {
     fn serialize(&self) -> Vec<u8> {
-        let mut rv: Vec<u8> = Vec::with_capacity(key_source_len(&self));
+        let mut rv: Vec<u8> = Vec::with_capacity(key_source_len(self));
 
         rv.append(&mut self.0.to_bytes().to_vec());
 
-        for cnum in self.1.into_iter() {
-            rv.append(&mut serialize(&u32::from(*cnum)))
+        for cnum in &self.1 {
+            rv.append(&mut serialize(&u32::from(*cnum)));
         }
 
         rv
@@ -136,19 +166,16 @@ impl Serialize for KeySource {
 
 impl Deserialize for KeySource {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        if bytes.len() < 4 {
+        let Some((prefix, mut rest)) = SliceExt::split_first_chunk::<4>(bytes) else {
             return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
-        }
+        };
 
-        let fprint: Fingerprint = Fingerprint::from(&bytes[0..4]);
-        let mut dpath: Vec<ChildNumber> = Default::default();
+        let fprint: Fingerprint = Fingerprint::from(prefix);
+        let mut dpath: Vec<ChildNumber> = Vec::default();
 
-        let mut d = &bytes[4..];
-        while !d.is_empty() {
-            match u32::consensus_decode(&mut d) {
-                Ok(index) => dpath.push(index.into()),
-                Err(e) => return Err(e),
-            }
+        while !rest.is_empty() {
+            let index = u32::consensus_decode(&mut rest)?;
+            dpath.push(index.into());
         }
 
         Ok((fprint, dpath.into()))
@@ -186,7 +213,7 @@ impl Serialize for confidential::Value {
         match self {
             confidential::Value::Null => vec![], // should never be invoked
             confidential::Value::Explicit(x) => Serialize::serialize(x),
-            y => encode::serialize(y), // confidential can serialized as is
+            confidential::Value::Confidential(_) => encode::serialize(self), // confidential can serialized as is
         }
     }
 }
@@ -231,7 +258,7 @@ impl Serialize for confidential::Asset {
         match self {
             confidential::Asset::Null => vec![], // should never be invoked
             confidential::Asset::Explicit(x) => Serialize::serialize(x),
-            y => encode::serialize(y), // confidential can serialized as is
+            confidential::Asset::Confidential(_) => encode::serialize(self), // confidential can serialized as is
         }
     }
 }
@@ -245,44 +272,40 @@ impl Deserialize for confidential::Asset {
     }
 }
 
-impl Serialize for Box<RangeProof> {
+impl Serialize for RangeProof {
     fn serialize(&self) -> Vec<u8> {
-        RangeProof::serialize(self)
+        self.to_vec()
     }
 }
 
-impl Deserialize for Box<RangeProof> {
+impl Deserialize for RangeProof {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        let prf = RangeProof::from_slice(&bytes)
-            .map_err(|_| encode::Error::ParseFailed("Invalid Rangeproof"))?;
-        Ok(Box::new(prf))
+        Self::from_slice(bytes).map_err(encode::Error::Secp256k1zkp)
     }
 }
 
-impl Serialize for Box<SurjectionProof> {
+impl Serialize for SurjectionProof {
     fn serialize(&self) -> Vec<u8> {
-        SurjectionProof::serialize(self)
+        self.to_vec()
     }
 }
 
-impl Deserialize for Box<SurjectionProof> {
+impl Deserialize for SurjectionProof {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        let prf = SurjectionProof::from_slice(&bytes)
-            .map_err(|_| encode::Error::ParseFailed("Invalid SurjectionProof"))?;
-        Ok(Box::new(prf))
+        Self::from_slice(bytes).map_err(encode::Error::Secp256k1zkp)
     }
 }
 
 // Taproot related ser/deser
-impl Serialize for bitcoin::XOnlyPublicKey {
+impl Serialize for XOnlyPublicKey {
     fn serialize(&self) -> Vec<u8> {
-        bitcoin::XOnlyPublicKey::serialize(&self).to_vec()
+        XOnlyPublicKey::serialize(self).to_vec()
     }
 }
 
-impl Deserialize for bitcoin::XOnlyPublicKey {
+impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        bitcoin::XOnlyPublicKey::from_slice(bytes)
+        XOnlyPublicKey::from_slice(bytes)
             .map_err(|_| encode::Error::ParseFailed("Invalid xonly public key"))
     }
 }
@@ -297,7 +320,7 @@ impl Deserialize for schnorr::SchnorrSig {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
         match bytes.len() {
             65 => {
-                let hash_ty = SchnorrSigHashType::from_u8(bytes[64])
+                let hash_ty = SchnorrSighashType::from_u8(bytes[64])
                     .ok_or(encode::Error::ParseFailed("Invalid Sighash type"))?;
                 let sig = secp256k1_zkp::schnorr::Signature::from_slice(&bytes[..64])
                     .map_err(|_| encode::Error::ParseFailed("Invalid Schnorr signature"))?;
@@ -308,7 +331,7 @@ impl Deserialize for schnorr::SchnorrSig {
                     .map_err(|_| encode::Error::ParseFailed("Invalid Schnorr signature"))?;
                 Ok(schnorr::SchnorrSig {
                     sig,
-                    hash_ty: SchnorrSigHashType::Default,
+                    hash_ty: SchnorrSighashType::Default,
                 })
             }
             _ => Err(encode::Error::ParseFailed("Invalid Schnorr signature len")),
@@ -316,22 +339,22 @@ impl Deserialize for schnorr::SchnorrSig {
     }
 }
 
-impl Serialize for (bitcoin::XOnlyPublicKey, TapLeafHash) {
+impl Serialize for (XOnlyPublicKey, TapLeafHash) {
     fn serialize(&self) -> Vec<u8> {
         let ser_pk = self.0.serialize();
-        let mut buf = Vec::with_capacity(ser_pk.len() + self.1.as_ref().len());
+        let mut buf = Vec::with_capacity(ser_pk.len() + TapLeafHash::LEN);
         buf.extend(&ser_pk);
-        buf.extend(self.1.as_ref());
+        buf.extend(&self.1.to_byte_array());
         buf
     }
 }
 
-impl Deserialize for (bitcoin::XOnlyPublicKey, TapLeafHash) {
+impl Deserialize for (XOnlyPublicKey, TapLeafHash) {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
         if bytes.len() < 32 {
             return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
         }
-        let a: bitcoin::XOnlyPublicKey = Deserialize::deserialize(&bytes[..32])?;
+        let a: XOnlyPublicKey = Deserialize::deserialize(&bytes[..32])?;
         let b: TapLeafHash = Deserialize::deserialize(&bytes[32..])?;
         Ok((a, b))
     }
@@ -339,7 +362,7 @@ impl Deserialize for (bitcoin::XOnlyPublicKey, TapLeafHash) {
 
 impl Serialize for ControlBlock {
     fn serialize(&self) -> Vec<u8> {
-        ControlBlock::serialize(&self)
+        ControlBlock::serialize(self)
     }
 }
 
@@ -386,7 +409,7 @@ impl Serialize for (Vec<TapLeafHash>, KeySource) {
 
 impl Deserialize for (Vec<TapLeafHash>, KeySource) {
     fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        let (leafhash_vec, consumed) = deserialize_partial::<Vec<TapLeafHash>>(&bytes)?;
+        let (leafhash_vec, consumed) = deserialize_partial::<Vec<TapLeafHash>>(bytes)?;
         let key_source = KeySource::deserialize(&bytes[consumed..])?;
         Ok((leafhash_vec, key_source))
     }
@@ -397,7 +420,7 @@ impl Serialize for TapTree {
         match (self.0.branch().len(), self.0.branch().last()) {
             (1, Some(Some(root))) => {
                 let mut buf = Vec::new();
-                for leaf_info in root.leaves.iter() {
+                for leaf_info in &root.leaves {
                     // # Cast Safety:
                     //
                     // TaprootMerkleBranch can only have len atmost 128(TAPROOT_CONTROL_MAX_NODE_COUNT).
diff --git a/src/pset/str.rs b/src/pset/str.rs
new file mode 100644
index 00000000..176e9ec9
--- /dev/null
+++ b/src/pset/str.rs
@@ -0,0 +1,49 @@
+use super::PartiallySignedTransaction;
+
+/// Possible errors when parsing a PSET from a string
+#[derive(Debug)]
+pub enum ParseError {
+    /// Base64 decoding error
+    Base64(bitcoin::base64::DecodeError),
+    /// PSET binary encoding error
+    Deserialize(crate::encode::Error)
+}
+
+impl core::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::Base64(_) => write!(f, "Base64 error"),
+            ParseError::Deserialize(_) => write!(f, "Deserialize error"),
+        }
+    }
+}
+
+impl std::error::Error for ParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            ParseError::Base64(e) => Some(e),
+            ParseError::Deserialize(e) => Some(e),
+        }
+    }
+
+}
+
+impl std::str::FromStr for PartiallySignedTransaction {
+    type Err=ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use bitcoin::base64::prelude::{Engine as _, BASE64_STANDARD};
+        let bytes = BASE64_STANDARD.decode(s).map_err(ParseError::Base64)?;
+        crate::encode::deserialize(&bytes).map_err(ParseError::Deserialize)
+    }
+}
+
+impl std::fmt::Display for PartiallySignedTransaction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use bitcoin::base64::prelude::BASE64_STANDARD;
+
+        let bytes = crate::encode::serialize(self);
+        let base64 = bitcoin::base64::display::Base64Display::new(&bytes, &BASE64_STANDARD);
+        write!(f, "{}", base64)
+    }
+}
diff --git a/src/schnorr.rs b/src/schnorr.rs
index d976a75d..238ae26e 100644
--- a/src/schnorr.rs
+++ b/src/schnorr.rs
@@ -19,12 +19,10 @@
 
 use std::fmt;
 
-use secp256k1_zkp::Scalar;
-pub use secp256k1_zkp::{XOnlyPublicKey, KeyPair};
-use secp256k1_zkp::{self, Secp256k1, Verification, constants::SCHNORR_SIGNATURE_SIZE};
-use crate::hashes::{Hash, HashEngine};
-use crate::taproot::{TapBranchHash, TapTweakHash};
-use crate::SchnorrSigHashType;
+use crate::taproot::{TapNodeHash, TapTweakHash};
+use crate::SchnorrSighashType;
+use secp256k1_zkp::{self, constants::SCHNORR_SIGNATURE_SIZE, Secp256k1, Verification};
+pub use secp256k1_zkp::{Keypair, XOnlyPublicKey};
 
 /// Untweaked Schnorr public key
 pub type UntweakedPublicKey = XOnlyPublicKey;
@@ -33,38 +31,70 @@ pub type UntweakedPublicKey = XOnlyPublicKey;
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct TweakedPublicKey(XOnlyPublicKey);
 
-/// A trait for tweaking Schnorr public keys
+/// Untweaked Schnorr key pair
+pub type UntweakedKeypair = Keypair;
+
+/// Tweaked Schnorr key pair
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct TweakedKeypair(Keypair);
+
+/// A trait for tweaking Schnorr key types (x-only public keys and key pairs).
 pub trait TapTweak {
-    /// Tweaks an untweaked public key given an untweaked key and optional script tree merkle root.
+    /// Tweaked key type with optional auxiliary information
+    type TweakedAux;
+    /// Tweaked key type
+    type TweakedKey;
+
+    /// Tweaks an untweaked key with corresponding public key value and optional script tree merkle
+    /// root. For the [`Keypair`] type this also tweaks the private key in the pair.
     ///
     /// This is done by using the equation Q = P + H(P|c)G, where
-    ///  * Q is the tweaked key
-    ///  * P is the internal key
+    ///  * Q is the tweaked public key
+    ///  * P is the internal public key
     ///  * H is the hash function
     ///  * c is the commitment data
     ///  * G is the generator point
-    fn tap_tweak<C: Verification>(self, secp: &Secp256k1<C>, merkle_root: Option<TapBranchHash>) -> (TweakedPublicKey, secp256k1_zkp::Parity);
+    ///
+    /// # Returns
+    /// The tweaked key and its parity.
+    fn tap_tweak<C: Verification>(
+        self,
+        secp: &Secp256k1<C>,
+        merkle_root: Option<TapNodeHash>,
+    ) -> Self::TweakedAux;
 
-    /// Directly convert an UntweakedPublicKey to a TweakedPublicKey
+    /// Directly converts to a `TweakedKey`
     ///
     /// 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.
-    fn dangerous_assume_tweaked(self) -> TweakedPublicKey;
+    fn dangerous_assume_tweaked(self) -> Self::TweakedKey;
 }
 
 impl TapTweak for UntweakedPublicKey {
-    fn tap_tweak<C: Verification>(self, secp: &Secp256k1<C>, merkle_root: Option<TapBranchHash>) -> (TweakedPublicKey, secp256k1_zkp::Parity) {
-        // Compute the tweak
-        let mut engine = TapTweakHash::engine();
-        engine.input(&self.serialize());
-        merkle_root.map(|hash| engine.input(&hash));
-        let tweak_value: [u8; 32] = TapTweakHash::from_engine(engine).into_inner();
-        let tweak_value = Scalar::from_be_bytes(tweak_value).expect("hash value greater than curve order");
-
-        //Tweak the internal key by the tweak value
-        let (output_key, parity) = self.clone().add_tweak(secp, &tweak_value).expect("Tap tweak failed");
-        debug_assert!(self.tweak_add_check(&secp, &output_key, parity, tweak_value));
+    type TweakedAux = (TweakedPublicKey, secp256k1_zkp::Parity);
+    type TweakedKey = TweakedPublicKey;
+
+    /// Tweaks an untweaked public key with corresponding public key value and optional script tree
+    /// merkle root.
+    ///
+    /// This is done by using the equation Q = P + H(P|c)G, where
+    ///  * Q is the tweaked public key
+    ///  * P is the internal public key
+    ///  * H is the hash function
+    ///  * c is the commitment data
+    ///  * G is the generator point
+    ///
+    /// # Returns
+    /// The tweaked key and its parity.
+    fn tap_tweak<C: Verification>(
+        self,
+        secp: &Secp256k1<C>,
+        merkle_root: Option<TapNodeHash>,
+    ) -> (TweakedPublicKey, secp256k1_zkp::Parity) {
+        let tweak = TapTweakHash::from_key_and_tweak(self, merkle_root).to_scalar();
+        let (output_key, parity) = self.add_tweak(secp, &tweak).expect("Tap tweak failed");
 
+        debug_assert!(self.tweak_add_check(secp, &output_key, parity, tweak));
         (TweakedPublicKey(output_key), parity)
     }
 
@@ -74,9 +104,44 @@ impl TapTweak for UntweakedPublicKey {
     }
 }
 
+impl TapTweak for UntweakedKeypair {
+    type TweakedAux = TweakedKeypair;
+    type TweakedKey = TweakedKeypair;
+
+    /// Tweaks private and public keys within an untweaked [`Keypair`] with corresponding public key
+    /// value and optional script tree merkle root.
+    ///
+    /// This is done by tweaking private key within the pair using the equation q = p + H(P|c), where
+    ///  * q is the tweaked private key
+    ///  * p is the internal private key
+    ///  * H is the hash function
+    ///  * c is the commitment data
+    ///
+    /// The public key is generated from a private key by multiplying with generator point, Q = qG.
+    ///
+    /// # Returns
+    /// The tweaked key and its parity.
+    fn tap_tweak<C: Verification>(self, secp: &Secp256k1<C>, merkle_root: Option<TapNodeHash>) -> TweakedKeypair {
+        let (pubkey, _parity) = XOnlyPublicKey::from_keypair(&self);
+        let tweak = TapTweakHash::from_key_and_tweak(pubkey, merkle_root).to_scalar();
+        let tweaked = self.add_xonly_tweak(secp, &tweak).expect("Tap tweak failed");
+        TweakedKeypair(tweaked)
+    }
+
+    fn dangerous_assume_tweaked(self) -> TweakedKeypair {
+        TweakedKeypair(self)
+    }
+}
 
 impl TweakedPublicKey {
-    /// Create a new [TweakedPublicKey] from a [PublicKey]. No tweak is applied.
+    /// Returns the [`TweakedPublicKey`] for `keypair`.
+    #[inline]
+    pub fn from_keypair(keypair: TweakedKeypair) -> Self {
+        let (xonly, _parity) = keypair.0.x_only_public_key();
+        TweakedPublicKey(xonly)
+    }
+
+    /// Create a new [`TweakedPublicKey`] from a [`XOnlyPublicKey`]. No tweak is applied.
     pub fn new(key: XOnlyPublicKey) -> TweakedPublicKey {
         TweakedPublicKey(key)
     }
@@ -92,14 +157,60 @@ impl TweakedPublicKey {
     }
 }
 
+impl TweakedKeypair {
+    /// Creates a new [`TweakedKeypair`] from a [`Keypair`]. No tweak is applied, consider
+    /// calling `tap_tweak` on an [`UntweakedKeypair`] instead of using this constructor.
+    ///
+    /// 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)
+    }
+
+    /// Returns the underlying key pair.
+    #[inline]
+    pub fn to_inner(self) -> Keypair {
+        self.0
+    }
+
+    /// Returns the [`TweakedPublicKey`] and its [`secp256k1_zkp::Parity`] for this [`TweakedKeypair`].
+    #[inline]
+    pub fn public_parts(&self) -> (TweakedPublicKey, secp256k1_zkp::Parity) {
+        let (xonly, parity) = self.0.x_only_public_key();
+        (TweakedPublicKey(xonly), parity)
+    }
+}
+
+impl From<TweakedPublicKey> for XOnlyPublicKey {
+    #[inline]
+    fn from(pair: TweakedPublicKey) -> Self {
+        pair.0
+    }
+}
+
+impl From<TweakedKeypair> for Keypair {
+    #[inline]
+    fn from(pair: TweakedKeypair) -> Self {
+        pair.0
+    }
+}
+
+impl From<TweakedKeypair> for TweakedPublicKey {
+    #[inline]
+    fn from(pair: TweakedKeypair) -> Self {
+        TweakedPublicKey::from_keypair(pair)
+    }
+}
+
 /// A BIP340-341 serialized schnorr signature with the corresponding hash type.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SchnorrSig {
     /// The underlying schnorr signature
     pub sig: secp256k1_zkp::schnorr::Signature,
     /// The corresponding hash type
-    pub hash_ty: SchnorrSigHashType,
+    pub hash_ty: SchnorrSighashType,
 }
 
 impl SchnorrSig {
@@ -110,22 +221,22 @@ impl SchnorrSig {
             // default type
             let sig = secp256k1_zkp::schnorr::Signature::from_slice(sl)
                 .map_err(|_| SchnorrSigError::InvalidSchnorrSig)?;
-            return Ok( SchnorrSig { sig, hash_ty : SchnorrSigHashType::Default });
+            return Ok( SchnorrSig { sig, hash_ty : SchnorrSighashType::Default });
         }
         let (hash_ty, sig) = sl.split_last()
-            .ok_or_else(|| SchnorrSigError::InvalidSchnorrSig)?;
-        let hash_ty = SchnorrSigHashType::from_u8(*hash_ty)
-            .ok_or_else(|| SchnorrSigError::InvalidSighashType(*hash_ty))?;
+            .ok_or(SchnorrSigError::InvalidSchnorrSig)?;
+        let hash_ty = SchnorrSighashType::from_u8(*hash_ty)
+            .ok_or(SchnorrSigError::InvalidSighashType(*hash_ty))?;
         let sig = secp256k1_zkp::schnorr::Signature::from_slice(sig)
             .map_err(|_| SchnorrSigError::InvalidSchnorrSig)?;
         Ok(SchnorrSig { sig, hash_ty })
     }
 
-    /// Serialize SchnorrSig
+    /// Serialize `SchnorrSig`
     pub fn to_vec(&self) -> Vec<u8> {
         // TODO: add support to serialize to a writer to SerializedSig
         let mut ser_sig = self.sig.as_ref().to_vec();
-        if let SchnorrSigHashType::Default = self.hash_ty {
+        if let SchnorrSighashType::Default = self.hash_ty {
             // default sighash type, don't add extra sighash byte
         } else {
             ser_sig.push(self.hash_ty as u8);
diff --git a/src/script.rs b/src/script.rs
index 1c8abd54..09fbb285 100644
--- a/src/script.rs
+++ b/src/script.rs
@@ -31,13 +31,13 @@ use secp256k1_zkp::{Verification, Secp256k1};
 #[cfg(feature = "serde")] use serde;
 
 use crate::encode::{self, Decodable, Encodable};
-use bitcoin::hashes::{Hash, hex};
+use crate::encoding;
 use crate::{opcodes, ScriptHash, WScriptHash, PubkeyHash, WPubkeyHash};
 
 use bitcoin::PublicKey;
 
 use crate::schnorr::{UntweakedPublicKey, TweakedPublicKey, TapTweak};
-use crate::taproot::TapBranchHash;
+use crate::taproot::TapNodeHash;
 
 const MAX_SCRIPT_SIZE : usize = 10_000;
 
@@ -77,22 +77,6 @@ impl fmt::UpperHex for Script {
     }
 }
 
-impl hex::FromHex for Script {
-    fn from_byte_iter<I>(iter: I) -> Result<Self, hex::Error>
-        where I: Iterator<Item=Result<u8, hex::Error>> +
-            ExactSizeIterator +
-            DoubleEndedIterator,
-    {
-        Vec::from_byte_iter(iter).map(|v| Script(Box::<[u8]>::from(v)))
-    }
-}
-impl str::FromStr for Script {
-    type Err = hex::Error;
-    fn from_str(s: &str) -> Result<Self, hex::Error> {
-        hex::FromHex::from_hex(s)
-    }
-}
-
 #[derive(PartialEq, Eq, Debug, Clone)]
 /// An object which can be used to construct a script piece by piece
 pub struct Builder(Vec<u8>, Option<opcodes::All>);
@@ -178,12 +162,14 @@ fn build_scriptint(n: i64) -> Vec<u8> {
 }
 
 /// Helper to decode an integer in script format
+///
 /// 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 in 4 bytes or less. This is ok! The number
 /// just can't be read as a number again.
+///
 /// This is a 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
@@ -197,7 +183,7 @@ pub fn read_scriptint(v: &[u8]) -> Result<i64, Error> {
     if len > 4 { return Err(Error::NumericOverflow); }
 
     let (mut ret, sh) = v.iter()
-                         .fold((0, 0), |(acc, sh), n| (acc + ((*n as i64) << sh), sh + 8));
+                         .fold((0, 0), |(acc, sh), n| (acc + ((i64::from(*n)) << sh), sh + 8));
     if v[len - 1] & 0x80 != 0 {
         ret &= (1 << (sh - 1)) - 1;
         ret = -ret;
@@ -231,6 +217,17 @@ impl Script {
     /// Creates a new empty script
     pub fn new() -> Script { Script(vec![].into_boxed_slice()) }
 
+    /// Parse a hex-string with no length prefix as a [`Script`].
+    #[deprecated(since = "0.27.0", note = "use from_hex_no_prefix instead")]
+    pub fn from_hex(s: &str) -> Result<Self, hex::DecodeVariableLengthBytesError> {
+        Self::from_hex_no_prefix(s)
+    }
+
+    /// Parse a hex-string with no length prefix as a [`Script`].
+    pub fn from_hex_no_prefix(s: &str) -> Result<Self, hex::DecodeVariableLengthBytesError> {
+        hex::decode_to_vec(s).map(|v| Script(Box::<[u8]>::from(v)))
+    }
+
     /// Generates P2PK-type of scriptPubkey
     pub fn new_p2pk(pubkey: &PublicKey) -> Script {
         Builder::new()
@@ -244,7 +241,7 @@ impl Script {
         Builder::new()
             .push_opcode(opcodes::all::OP_DUP)
             .push_opcode(opcodes::all::OP_HASH160)
-            .push_slice(&pubkey_hash[..])
+            .push_slice(pubkey_hash.as_ref())
             .push_opcode(opcodes::all::OP_EQUALVERIFY)
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .into_script()
@@ -254,36 +251,36 @@ impl Script {
     pub fn new_p2sh(script_hash: &ScriptHash) -> Script {
         Builder::new()
             .push_opcode(opcodes::all::OP_HASH160)
-            .push_slice(&script_hash[..])
+            .push_slice(script_hash.as_byte_array())
             .push_opcode(opcodes::all::OP_EQUAL)
             .into_script()
     }
 
     /// Generates P2WPKH-type of scriptPubkey
     pub fn new_v0_wpkh(pubkey_hash: &WPubkeyHash) -> Script {
-        Script::new_witness_program(crate::bech32::u5::try_from_u8(0).unwrap(), &pubkey_hash.to_vec())
+        Script::new_witness_program(bech32::Fe32::Q, pubkey_hash.as_ref())
     }
 
     /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script
     pub fn new_v0_wsh(script_hash: &WScriptHash) -> Script {
-        Script::new_witness_program(crate::bech32::u5::try_from_u8(0).unwrap(), &script_hash.to_vec())
+        Script::new_witness_program(bech32::Fe32::Q, script_hash.as_byte_array())
     }
 
     /// Generates P2TR for script spending path using an internal public key and some optional
     /// script tree merkle root.
-    pub fn new_v1_p2tr<C: Verification>(secp: &Secp256k1<C>, internal_key: UntweakedPublicKey, merkle_root: Option<TapBranchHash>) -> Script {
+    pub fn new_v1_p2tr<C: Verification>(secp: &Secp256k1<C>, internal_key: UntweakedPublicKey, merkle_root: Option<TapNodeHash>) -> Script {
         let (output_key, _) = internal_key.tap_tweak(secp, merkle_root);
-        Script::new_witness_program(crate::bech32::u5::try_from_u8(1).unwrap(), &output_key.as_inner().serialize())
+        Script::new_witness_program(bech32::Fe32::P, &output_key.as_inner().serialize())
     }
 
     /// Generates P2TR for key spending path for a known [`TweakedPublicKey`].
     pub fn new_v1_p2tr_tweaked(output_key: TweakedPublicKey) -> Script {
-        Script::new_witness_program(crate::bech32::u5::try_from_u8(1).unwrap(), &output_key.as_inner().serialize())
+        Script::new_witness_program(bech32::Fe32::P, &output_key.as_inner().serialize())
     }
 
 
     /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script
-    pub fn new_witness_program(ver: crate::bech32::u5, program: &[u8]) -> Script {
+    pub fn new_witness_program(ver: bech32::Fe32, program: &[u8]) -> Script {
         let mut verop = ver.to_u8();
         assert!(verop <= 16, "incorrect witness version provided: {}", verop);
         if verop > 0 {
@@ -291,7 +288,7 @@ impl Script {
         }
         Builder::new()
             .push_opcode(verop.into())
-            .push_slice(&program)
+            .push_slice(program)
             .into_script()
     }
 
@@ -305,12 +302,12 @@ impl Script {
 
     /// Returns 160-bit hash of the script
     pub fn script_hash(&self) -> ScriptHash {
-        ScriptHash::hash(&self.as_bytes())
+        ScriptHash(hashes::hash160::hash(self.as_bytes()))
     }
 
     /// Returns 256-bit hash of the script for P2WSH outputs
     pub fn wscript_hash(&self) -> WScriptHash {
-        WScriptHash::hash(&self.as_bytes())
+        WScriptHash(hashes::sha256::hash(self.as_bytes()))
     }
 
     /// The length in bytes of the script
@@ -320,7 +317,7 @@ impl Script {
     pub fn is_empty(&self) -> bool { self.0.is_empty() }
 
     /// Returns the script data
-    pub fn as_bytes(&self) -> &[u8] { &*self.0 }
+    pub fn as_bytes(&self) -> &[u8] { &self.0 }
 
     /// Returns a copy of the script data
     pub fn to_bytes(&self) -> Vec<u8> { self.0.clone().into_vec() }
@@ -329,18 +326,20 @@ impl Script {
     pub fn into_bytes(self) -> Vec<u8> { self.0.into_vec() }
 
     /// Compute the P2SH output corresponding to this redeem script
+    #[must_use]
     pub fn to_p2sh(&self) -> Script {
         Builder::new().push_opcode(opcodes::all::OP_HASH160)
-                      .push_slice(&ScriptHash::hash(&self.0)[..])
+                      .push_slice(self.script_hash().as_byte_array())
                       .push_opcode(opcodes::all::OP_EQUAL)
                       .into_script()
     }
 
     /// Compute the P2WSH output corresponding to this witnessScript (aka the "witness redeem
     /// script")
+    #[must_use]
     pub fn to_v0_p2wsh(&self) -> Script {
         Builder::new().push_int(0)
-                      .push_slice(&WScriptHash::hash(&self.0)[..])
+                      .push_slice(self.wscript_hash().as_byte_array())
                       .into_script()
     }
 
@@ -429,14 +428,14 @@ impl Script {
             self.0[1] == opcodes::all::OP_PUSHBYTES_20.into_u8()
     }
 
-    /// Check if this is an OP_RETURN output
+    /// Check if this is an `OP_RETURN` output
     pub fn is_op_return (&self) -> bool {
         !self.0.is_empty() && (opcodes::All::from(self.0[0]) == opcodes::all::OP_RETURN)
     }
 
     /// Whether a script can be proven to have no satisfying input
-    /// In elements, is_provably_unspendable is consensus critical
-    /// matches the implementation of CScript::IsUnspendable()
+    /// In elements, `is_provably_unspendable` is consensus critical
+    /// matches the implementation of `CScript::IsUnspendable()`
     pub fn is_provably_unspendable(&self) -> bool {
         !self.0.is_empty() && opcodes::All::from(self.0[0]) == opcodes::all::OP_RETURN
         || self.len() > MAX_SCRIPT_SIZE
@@ -448,8 +447,8 @@ impl Script {
     /// iterator will end. To instead iterate over the script as sequence of bytes, treat
     /// it as a slice using `script[..]` or convert it to a vector using `into_bytes()`.
     ///
-    /// To force minimal pushes, use [instructions_minimal].
-    pub fn instructions(&self) -> Instructions {
+    /// To force minimal pushes, use [`Script::instructions_minimal`].
+    pub fn instructions(&self) -> Instructions<'_> {
         Instructions {
             data: &self.0[..],
             enforce_minimal: false,
@@ -458,7 +457,7 @@ impl Script {
 
     /// Iterate over the script in the form of `Instruction`s while enforcing
     /// minimal pushes.
-    pub fn instructions_minimal(&self) -> Instructions {
+    pub fn instructions_minimal(&self) -> Instructions<'_> {
         Instructions {
             data: &self.0[..],
             enforce_minimal: true,
@@ -481,9 +480,12 @@ impl Script {
                             f.write_str("<unexpected end>")?;
                             break;
                         }
-                        match read_uint(&self.0[index..], 1) {
-                            Ok(n) => { index += 1; n as usize }
-                            Err(_) => { f.write_str("<bad length>")?; break; }
+                        if let Ok(n) =read_uint(&self.0[index..], 1) {
+                            index += 1;
+                            n
+                        } else {
+                            f.write_str("<bad length>")?;
+                            break;
                         }
                     }
                     opcodes::all::OP_PUSHDATA2 => {
@@ -491,9 +493,12 @@ impl Script {
                             f.write_str("<unexpected end>")?;
                             break;
                         }
-                        match read_uint(&self.0[index..], 2) {
-                            Ok(n) => { index += 2; n as usize }
-                            Err(_) => { f.write_str("<bad length>")?; break; }
+                        if let Ok(n) = read_uint(&self.0[index..], 2) {
+                            index += 2;
+                            n
+                        } else {
+                            f.write_str("<bad length>")?;
+                            break;
                         }
                     }
                     opcodes::all::OP_PUSHDATA4 => {
@@ -501,9 +506,12 @@ impl Script {
                             f.write_str("<unexpected end>")?;
                             break;
                         }
-                        match read_uint(&self.0[index..], 4) {
-                            Ok(n) => { index += 4; n as usize }
-                            Err(_) => { f.write_str("<bad length>")?; break; }
+                        if let Ok(n) = read_uint(&self.0[index..], 4) {
+                            index += 4;
+                            n
+                        } else {
+                            f.write_str("<bad length>")?;
+                            break;
                         }
                     }
                     _ => 0
@@ -592,7 +600,7 @@ pub enum Instruction<'a> {
 }
 
 impl<'a> Instruction<'a> {
-    /// Get the opcode in case of [Instruction::Op].
+    /// Get the opcode in case of [`Instruction::Op`].
     pub fn op(&self) -> Option<opcodes::All> {
         if let Instruction::Op(o) = self {
             Some(*o)
@@ -601,7 +609,7 @@ impl<'a> Instruction<'a> {
         }
     }
 
-    /// Get the push bytes in case of [Instruction::PushBytes].
+    /// Get the push bytes in case of [`Instruction::PushBytes`].
     pub fn push_bytes(&self) -> Option<&'a [u8]> {
         if let Instruction::PushBytes(p) = self {
             Some(p)
@@ -638,7 +646,7 @@ impl<'a> Iterator for Instructions<'a> {
                         self.data = &[];
                         return Some(Err(Error::NonMinimalPush));
                 }
-                let ret = Some(Ok(Instruction::PushBytes(&self.data[1..n+1])));
+                let ret = Some(Ok(Instruction::PushBytes(&self.data[1..=n])));
                 self.data = &self.data[n + 1..];
                 ret
             }
@@ -739,11 +747,12 @@ impl Builder {
     /// Adds instructions to push an integer onto the stack. Integers are
     /// encoded as little-endian signed-magnitude numbers, but there are
     /// dedicated opcodes to push some small integers.
+    #[must_use]
     pub fn push_int(self, data: i64) -> Builder {
         // We can special-case -1, 1-16
         if data == -1 || (data >= 1 && data <= 16) {
             let opcode = opcodes::All::from(
-                (data - 1 + opcodes::OP_TRUE.into_u8() as i64) as u8
+                (data - 1 + i64::from(opcodes::OP_TRUE.into_u8())) as u8
             );
             self.push_opcode(opcode)
         }
@@ -757,11 +766,13 @@ impl Builder {
 
     /// Adds instructions to push an integer onto the stack, using the explicit
     /// encoding regardless of the availability of dedicated opcodes.
+    #[must_use]
     pub fn push_scriptint(self, data: i64) -> Builder {
         self.push_slice(&build_scriptint(data))
     }
 
     /// Adds instructions to push some arbitrary data onto the stack
+    #[must_use]
     pub fn push_slice(mut self, data: &[u8]) -> Builder {
         // Start with a PUSH opcode
         match data.len() as u64 {
@@ -770,27 +781,28 @@ impl Builder {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA1.into_u8());
                 self.0.push(n as u8);
             },
-            n if n < 0x10000 => {
+            n if n < 0x1_0000 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA2.into_u8());
                 self.0.push((n % 0x100) as u8);
                 self.0.push((n / 0x100) as u8);
             },
-            n if n < 0x100000000 => {
+            n if n < 0x1_0000_0000 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA4.into_u8());
                 self.0.push((n % 0x100) as u8);
                 self.0.push(((n / 0x100) % 0x100) as u8);
-                self.0.push(((n / 0x10000) % 0x100) as u8);
-                self.0.push((n / 0x1000000) as u8);
+                self.0.push(((n / 0x1_0000) % 0x100) as u8);
+                self.0.push((n / 0x100_0000) as u8);
             }
             _ => panic!("tried to put a 4bn+ sized object into a script!")
         }
         // Then push the raw bytes
-        self.0.extend(data.iter().cloned());
+        self.0.extend(data.iter().copied());
         self.1 = None;
         self
     }
 
     /// Pushes a public key
+    #[must_use]
     pub fn push_key(self, key: &PublicKey) -> Builder {
         if key.compressed {
             self.push_slice(&key.inner.serialize()[..])
@@ -800,6 +812,7 @@ impl Builder {
     }
 
     /// Adds a single opcode to the script
+    #[must_use]
     pub fn push_opcode(mut self, data: opcodes::All) -> Builder {
         self.0.push(data.into_u8());
         self.1 = Some(data);
@@ -809,6 +822,7 @@ impl Builder {
     /// Adds an `OP_VERIFY` to the script, unless the most-recently-added
     /// opcode has an alternate `VERIFY` form, in which case that opcode
     /// is replaced. e.g. `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
+    #[must_use]
     pub fn push_verify(mut self) -> Builder {
         match self.1 {
             Some(opcodes::all::OP_EQUAL) => {
@@ -865,7 +879,6 @@ impl<'de> serde::Deserialize<'de> for Script {
         D: serde::Deserializer<'de>,
     {
         use std::fmt::Formatter;
-        use bitcoin::hashes::hex::FromHex;
 
         struct Visitor;
         impl<'de> serde::de::Visitor<'de> for Visitor {
@@ -879,7 +892,7 @@ impl<'de> serde::Deserialize<'de> for Script {
             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(Script::from(v))
             }
 
@@ -931,9 +944,38 @@ impl Decodable for Script {
     }
 }
 
+encoding::encoder_newtype_exact! {
+    /// Encoder for a [`Script`].
+    #[derive(Clone, Debug)]
+    pub struct ScriptEncoder<'e>(encoding::PrefixedBytesEncoder<'e>);
+}
+
+impl encoding::Encode for Script {
+    type Encoder<'e> = ScriptEncoder<'e>;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        ScriptEncoder::new(encoding::PrefixedBytesEncoder::new(self.as_bytes()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for a [`Script`].
+    #[derive(Default)]
+    pub struct ScriptDecoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`Script`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct ScriptDecoderError(encoding::ByteVecDecoderError);
+    const ERROR_DISPLAY = "failed to decode script";
+
+    impl Decode for Script {
+        fn convert_inner(bytes) -> Result<_, _> {
+            Ok(Script::from(bytes))
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
-    use bitcoin::hashes::hex::FromHex;
     use bitcoin::PublicKey;
     use std::str::FromStr;
 
@@ -945,6 +987,10 @@ mod test {
 
     #[test]
     fn script() {
+        // Clippy likes these at the top of the method
+        const KEYSTR_C: &str = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
+        const KEYSTR_U: &str = "41042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
+
         let mut comp = vec![];
         let mut script = Builder::new();
         assert_eq!(&script[..], &comp[..]);
@@ -955,24 +1001,22 @@ mod test {
         script = script.push_int(4);  comp.push(84u8); assert_eq!(&script[..], &comp[..]);
         script = script.push_int(-1); comp.push(79u8); assert_eq!(&script[..], &comp[..]);
         // forced scriptint
-        script = script.push_scriptint(4); comp.extend([1u8, 4].iter().cloned()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_scriptint(4); comp.extend([1u8, 4].iter().copied()); assert_eq!(&script[..], &comp[..]);
         // big ints
-        script = script.push_int(17); comp.extend([1u8, 17].iter().cloned()); assert_eq!(&script[..], &comp[..]);
-        script = script.push_int(10000); comp.extend([2u8, 16, 39].iter().cloned()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(17); comp.extend([1u8, 17].iter().copied()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(10_000); comp.extend([2u8, 16, 39].iter().copied()); assert_eq!(&script[..], &comp[..]);
         // notice the sign bit set here, hence the extra zero/128 at the end
-        script = script.push_int(10000000); comp.extend([4u8, 128, 150, 152, 0].iter().cloned()); assert_eq!(&script[..], &comp[..]);
-        script = script.push_int(-10000000); comp.extend([4u8, 128, 150, 152, 128].iter().cloned()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(10_000_000); comp.extend([4u8, 128, 150, 152, 0].iter().copied()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_int(-10_000_000); comp.extend([4u8, 128, 150, 152, 128].iter().copied()); assert_eq!(&script[..], &comp[..]);
 
         // data
-        script = script.push_slice(b"NRA4VR"); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().cloned()); assert_eq!(&script[..], &comp[..]);
+        script = script.push_slice(b"NRA4VR"); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().copied()); assert_eq!(&script[..], &comp[..]);
 
         // keys
-        let keystr = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
-        let key = PublicKey::from_str(&keystr[2..]).unwrap();
-        script = script.push_key(&key); comp.extend(Vec::from_hex(keystr).unwrap().iter().cloned()); assert_eq!(&script[..], &comp[..]);
-        let keystr = "41042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
-        let key = PublicKey::from_str(&keystr[2..]).unwrap();
-        script = script.push_key(&key); comp.extend(Vec::from_hex(keystr).unwrap().iter().cloned()); assert_eq!(&script[..], &comp[..]);
+        let key = PublicKey::from_str(&KEYSTR_C[2..]).unwrap();
+        script = script.push_key(&key); comp.extend(hex::hex!(KEYSTR_C).iter().copied()); assert_eq!(&script[..], &comp[..]);
+        let key = PublicKey::from_str(&KEYSTR_U[2..]).unwrap();
+        script = script.push_key(&key); comp.extend(hex::hex!(KEYSTR_U).iter().copied()); assert_eq!(&script[..], &comp[..]);
 
         // opcodes
         script = script.push_opcode(opcodes::all::OP_CHECKSIG); comp.push(0xACu8); assert_eq!(&script[..], &comp[..]);
@@ -984,7 +1028,7 @@ mod test {
         // from txid 3bb5e6434c11fb93f64574af5d116736510717f2c595eb45b52c28e31622dfff which was in my mempool when I wrote the test
         let script = Builder::new().push_opcode(opcodes::all::OP_DUP)
                                    .push_opcode(opcodes::all::OP_HASH160)
-                                   .push_slice(&Vec::from_hex("16e1ae70ff0fa102905d4af297f6912bda6cce19").unwrap())
+                                   .push_slice(&hex::hex!("16e1ae70ff0fa102905d4af297f6912bda6cce19"))
                                    .push_opcode(opcodes::all::OP_EQUALVERIFY)
                                    .push_opcode(opcodes::all::OP_CHECKSIG)
                                    .into_script();
@@ -1065,7 +1109,7 @@ mod test {
 
     #[test]
     fn script_serialize() {
-        let hex_script = Vec::from_hex("6c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52").unwrap();
+        let hex_script = hex::hex!("6c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52");
         let script: Result<Script, _> = deserialize(&hex_script);
         assert!(script.is_ok());
         assert_eq!(serialize(&script.unwrap()), hex_script);
@@ -1078,8 +1122,8 @@ mod test {
         assert_eq!(build_scriptint(256), vec![0, 1]);
         assert_eq!(build_scriptint(257), vec![1, 1]);
         assert_eq!(build_scriptint(511), vec![255, 1]);
-        for &i in [10, 100, 255, 256, 1000, 10000, 25000, 200000, 5000000, 1000000000,
-                             (1 << 31) - 1, -((1 << 31) - 1)].iter() {
+        for &i in &[10, 100, 255, 256, 1000, 10000, 25000, 200_000, 5_000_000, 1_000_000_000,
+                             (1 << 31) - 1, -((1 << 31) - 1)] {
             assert_eq!(Ok(i), read_scriptint(&build_scriptint(i)));
             assert_eq!(Ok(-i), read_scriptint(&build_scriptint(-i)));
         }
@@ -1090,18 +1134,18 @@ mod test {
     #[test]
     fn provably_unspendable_test() {
         // p2pk
-        assert_eq!(hex_script!("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").is_provably_unspendable(), false);
+        assert!(!hex_script!("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").is_provably_unspendable());
+        assert!(!hex_script!("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").is_provably_unspendable());
         // p2pkhash
-        assert_eq!(hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_provably_unspendable(), true);
+        assert!(!hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_provably_unspendable());
+        assert!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_provably_unspendable());
     }
 
     #[test]
     fn op_return_test() {
-        assert_eq!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_op_return(), true);
-        assert_eq!(hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_op_return(), false);
-        assert_eq!(hex_script!("").is_op_return(), false);
+        assert!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_op_return());
+        assert!(!hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_op_return());
+        assert!(!hex_script!("").is_op_return());
     }
 
     #[test]
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
deleted file mode 100644
index 3b05d528..00000000
--- a/src/serde_utils.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-//! Module for special serde serializations.
-//! Copied from rust-bitcoin as is.
-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 ::std::collections::BTreeMap;
-    use bitcoin::hashes::hex::{FromHex, ToHex};
-    use serde;
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::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, &value.to_hex())?;
-            }
-            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> + ::std::hash::Hash + Eq + Ord,
-    {
-        use ::std::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T> where
-            T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::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 ::std::collections::BTreeMap;
-    use serde;
-
-    pub fn serialize<S, T, U>(v: &BTreeMap<T, U>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::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> + ::std::hash::Hash + Eq + Ord,
-        U: serde::Deserialize<'de>,
-    {
-        use ::std::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> + ::std::hash::Hash + Eq + Ord,
-            U: serde::Deserialize<'de>,
-        {
-            type Value = BTreeMap<T, U>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::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 ::std::collections::BTreeMap;
-    use serde;
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Deserialize)]
-    #[serde(crate = "actual_serde")]
-    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)]
-    #[serde(crate = "actual_serde")]
-    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 + ::std::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> + ::std::hash::Hash + Eq + Ord,
-    {
-        use ::std::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T> where
-            T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::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 bitcoin::hashes::hex::{FromHex, ToHex};
-    use serde;
-
-    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 {
-            s.serialize_str(&bytes.as_ref().to_hex())
-        }
-    }
-
-    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>(::std::marker::PhantomData<B>);
-
-        impl<'de, B: FromHex> serde::de::Visitor<'de> for Visitor<B> {
-            type Value = B;
-
-            fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::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) = ::std::str::from_utf8(v) {
-                    FromHex::from_hex(hex).map_err(E::custom)
-                } else {
-                    return 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(::std::marker::PhantomData))
-        }
-    }
-}
diff --git a/src/sighash.rs b/src/sighash.rs
index 66186fa1..d1710bf0 100644
--- a/src/sighash.rs
+++ b/src/sighash.rs
@@ -19,14 +19,16 @@
 //! signatures, which are placed in the scriptSig.
 //!
 
+use std::borrow::Borrow;
 use crate::encode::{self, Encodable};
-use crate::hash_types::SigHash;
-use crate::hashes::{sha256d, Hash, sha256};
+use crate::hash_types::Sighash;
+use crate::hashes::{sha256d, sha256t, sha256, HashEngine as _};
 use crate::script::Script;
 use std::ops::{Deref, DerefMut};
 use std::io;
 use crate::endian;
-use crate::transaction::{EcdsaSigHashType, Transaction, TxIn, TxOut, TxInWitness};
+use crate::taproot::LeafVersion;
+use crate::transaction::{EcdsaSighashType, Transaction, TxIn, TxOut, TxInWitness};
 use crate::confidential;
 use crate::Sequence;
 use std::fmt;
@@ -37,10 +39,10 @@ use crate::BlockHash;
 use crate::transaction::SighashTypeParseError;
 /// Efficiently calculates signature hash message for legacy, segwit and taproot inputs.
 #[derive(Debug)]
-pub struct SigHashCache<T: Deref<Target = Transaction>> {
+pub struct SighashCache<T: Deref<Target = Transaction>> {
     /// Access to transaction required for various introspection, moreover type
     /// `T: Deref<Target=Transaction>` allows to accept borrow and mutable borrow, the
-    /// latter in particular is necessary for [`SigHashCache::witness_mut`]
+    /// latter in particular is necessary for [`SighashCache::witness_mut`]
     tx: T,
 
     /// Common cache for taproot and segwit inputs. It's an option because it's not needed for legacy inputs
@@ -85,16 +87,16 @@ struct TaprootCache {
 }
 
 /// Contains outputs of previous transactions.
-/// In the case [`SchnorrSigHashType`] variant is `ANYONECANPAY`, [`Prevouts::One`] may be provided
+/// In the case [`SchnorrSighashType`] variant is `ANYONECANPAY`, [`Prevouts::One`] may be provided
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub enum Prevouts<'u> {
+pub enum Prevouts<'u, T> where T: 'u + Borrow<TxOut> {
     /// `One` variant allows to provide the single Prevout needed. It's useful for example
     /// when modifier `ANYONECANPAY` is provided, only prevout of the current input is needed.
     /// The first `usize` argument is the input index this [`TxOut`] is referring to.
-    One(usize, &'u TxOut),
+    One(usize, T),
     /// When `ANYONECANPAY` is not provided, or the caller is handy giving all prevouts so the same
     /// variable can be used for multiple inputs.
-    All(&'u [TxOut]),
+    All(&'u [T]),
 }
 
 const KEY_VERSION_0: u8 = 0u8;
@@ -104,7 +106,7 @@ const KEY_VERSION_0: u8 = 0u8;
 pub struct ScriptPath<'s> {
     script: &'s Script,
     code_separator_pos: u32,
-    leaf_version: u8,
+    leaf_version: LeafVersion,
 }
 
 /// Possible errors in computing the signature message
@@ -122,7 +124,7 @@ pub enum Error {
         inputs_size: usize,
     },
 
-    /// Using SIGHASH_SINGLE without a "corresponding output" (an output with the same index as the
+    /// Using `SIGHASH_SINGLE` without a "corresponding output" (an output with the same index as the
     /// input being verified) is a validation failure
     SingleWithoutCorrespondingOutput {
         /// Requested index
@@ -146,7 +148,7 @@ pub enum Error {
     WrongAnnex,
 
     /// Invalid Sighash type
-    InvalidSigHashType(u8),
+    InvalidSighashType(u8),
 }
 
 impl fmt::Display for Error {
@@ -159,14 +161,14 @@ impl fmt::Display for Error {
             Error::PrevoutIndex => write!(f, "The index requested is greater than available prevouts or different from the provided [Provided::Anyone] index"),
             Error::PrevoutKind => write!(f, "A single prevout has been provided but all prevouts are needed without `ANYONECANPAY`"),
             Error::WrongAnnex => write!(f, "Annex must be at least one byte long and the first bytes must be `0x50`"),
-            Error::InvalidSigHashType(hash_ty) => write!(f, "Invalid schnorr Signature hash type : {} ", hash_ty),
+            Error::InvalidSighashType(hash_ty) => write!(f, "Invalid schnorr Signature hash type : {} ", hash_ty),
         }
     }
 }
 
 impl ::std::error::Error for Error {}
 
-impl<'u> Prevouts<'u> {
+impl<T> Prevouts<'_, T> where T: Borrow<TxOut> {
     fn check_all(&self, tx: &Transaction) -> Result<(), Error> {
         if let Prevouts::All(prevouts) = self {
             if prevouts.len() != tx.input.len() {
@@ -176,10 +178,10 @@ impl<'u> Prevouts<'u> {
         Ok(())
     }
 
-    fn get_all(&self) -> Result<&[TxOut], Error> {
+    fn get_all(&self) -> Result<&[T], Error> {
         match self {
-            Prevouts::All(prevouts) => Ok(prevouts),
-            _ => Err(Error::PrevoutKind),
+            Prevouts::All(prevouts) => Ok(*prevouts),
+            Prevouts::One(..) => Err(Error::PrevoutKind),
         }
     }
 
@@ -187,38 +189,36 @@ impl<'u> Prevouts<'u> {
         match self {
             Prevouts::One(index, prevout) => {
                 if input_index == *index {
-                    Ok(prevout)
+                    Ok(prevout.borrow())
                 } else {
                     Err(Error::PrevoutIndex)
                 }
             }
-            Prevouts::All(prevouts) => prevouts.get(input_index).ok_or(Error::PrevoutIndex),
+            Prevouts::All(prevouts) => prevouts
+                .get(input_index)
+                .map(T::borrow)
+                .ok_or(Error::PrevoutIndex),
         }
     }
 }
 
 impl<'s> ScriptPath<'s> {
-    /// Create a new ScriptPath structure
-    pub fn new(script: &'s Script, code_separator_pos: u32, leaf_version: u8) -> Self {
+    /// Create a new `ScriptPath` structure
+    pub fn new(script: &'s Script, code_separator_pos: u32, leaf_version: LeafVersion) -> Self {
         ScriptPath {
             script,
             code_separator_pos,
             leaf_version,
         }
     }
-    /// Create a new ScriptPath structure using default values for `code_separator_pos` and `leaf_version`
+    /// Create a new `ScriptPath` structure using default values for `code_separator_pos` and `leaf_version`
     pub fn with_defaults(script: &'s Script) -> Self {
-        Self::new(script, 0xFFFFFFFFu32, 0xc4)
+        Self::new(script, 0xFFFF_FFFFu32, LeafVersion::TAPSCRIPT)
     }
 
     /// Compute the leaf hash
     pub fn leaf_hash(&self) -> TapLeafHash {
-        let mut enc = TapLeafHash::engine();
-
-        self.leaf_version.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");
-
-        TapLeafHash::from_engine(enc)
+        TapLeafHash::from_script(self.script, self.leaf_version)
     }
 }
 
@@ -228,13 +228,13 @@ impl<'s> From<ScriptPath<'s>> for TapLeafHash {
     }
 }
 
-impl<R: Deref<Target = Transaction>> SigHashCache<R> {
+impl<R: Deref<Target = Transaction>> SighashCache<R> {
     /// Compute the sighash components from an unsigned transaction and auxiliary
     /// in a lazy manner when required.
     /// For the generated sighashes to be valid, no fields in the transaction may change except for
-    /// script_sig and witnesses.
+    /// `script_sig` and witnesses.
     pub fn new(tx: R) -> Self {
-        SigHashCache {
+        SighashCache {
             tx,
             common_cache: None,
             taproot_cache: None,
@@ -243,15 +243,16 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
     }
 
     /// Encode the BIP341 signing data for any flag type into a given object implementing a
-    /// io::Write trait.
-    pub fn taproot_encode_signing_data_to<Write: io::Write>(
+    /// `io::Write` trait.
+    #[allow(clippy::too_many_arguments)]
+    pub fn taproot_encode_signing_data_to<Write: io::Write, T: Borrow<TxOut>>(
         &mut self,
         mut writer: Write,
         input_index: usize,
-        prevouts: &Prevouts,
+        prevouts: &Prevouts<T>,
         annex: Option<Annex>,
         leaf_hash_code_separator: Option<(TapLeafHash, u32)>,
-        sighash_type: SchnorrSigHashType,
+        sighash_type: SchnorrSighashType,
         genesis_hash: BlockHash,
     ) -> Result<(), Error> {
         prevouts.check_all(&self.tx)?;
@@ -308,7 +309,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         // If hash_type & 3 does not equal SIGHASH_NONE or SIGHASH_SINGLE:
         //     sha_outputs (32): the SHA256 of the serialization of all outputs in CTxOut format.
         //     sha_output_witnesses (32): (ELEMENTS) the SHA256 of the serialization of all output witnesses
-        if sighash != SchnorrSigHashType::None && sighash != SchnorrSigHashType::Single {
+        if sighash != SchnorrSighashType::None && sighash != SchnorrSighashType::Single {
             self.common_cache().outputs.consensus_encode(&mut writer)?;
             self.taproot_cache(prevouts.get_all()?)
                 .output_witnesses
@@ -342,7 +343,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
                     .tx
                     .input
                     .get(input_index)
-                    .ok_or_else(|| Error::IndexOutOfInputsBounds {
+                    .ok_or(Error::IndexOutOfInputsBounds {
                         index: input_index,
                         inputs_size: self.tx.input.len(),
                     })?;
@@ -383,12 +384,12 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         // If hash_type & 3 equals SIGHASH_SINGLE:
         //      sha_single_output (32): the SHA256 of the corresponding output in CTxOut format.
         //      sha_single_output_witness (32): the sha256 serialization of output witnesses
-        if sighash == SchnorrSigHashType::Single {
+        if sighash == SchnorrSighashType::Single {
             let mut enc = sha256::Hash::engine();
             let out = self.tx
                 .output
                 .get(input_index)
-                .ok_or_else(|| Error::SingleWithoutCorrespondingOutput {
+                .ok_or(Error::SingleWithoutCorrespondingOutput {
                     index: input_index,
                     outputs_size: self.tx.output.len(),
                 })?;
@@ -408,7 +409,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         //         ss += bytes([0])
         //         ss += struct.pack("<i", codeseparator_pos)
         if let Some((hash, code_separator_pos)) = leaf_hash_code_separator {
-            hash.into_inner().consensus_encode(&mut writer)?;
+            hash.to_byte_array().consensus_encode(&mut writer)?;
             KEY_VERSION_0.consensus_encode(&mut writer)?;
             code_separator_pos.consensus_encode(&mut writer)?;
         }
@@ -417,16 +418,16 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
     }
 
     /// Compute the BIP341 sighash for any flag type.
-    pub fn taproot_sighash(
+    pub fn taproot_sighash<T: Borrow<TxOut>>(
         &mut self,
         input_index: usize,
-        prevouts: &Prevouts,
+        prevouts: &Prevouts<T>,
         annex: Option<Annex>,
         leaf_hash_code_separator: Option<(TapLeafHash, u32)>,
-        sighash_type: SchnorrSigHashType,
+        sighash_type: SchnorrSighashType,
         genesis_hash: BlockHash,
     ) -> Result<TapSighashHash, Error> {
-        let mut enc = TapSighashHash::engine();
+        let mut enc = sha256t::Hash::engine();
         self.taproot_encode_signing_data_to(
             &mut enc,
             input_index,
@@ -436,18 +437,18 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
             sighash_type,
             genesis_hash,
         )?;
-        Ok(TapSighashHash::from_engine(enc))
+        Ok(TapSighashHash(enc.finalize()))
     }
 
     /// Compute the BIP341 sighash for a key spend
-    pub fn taproot_key_spend_signature_hash(
+    pub fn taproot_key_spend_signature_hash<T: Borrow<TxOut>>(
         &mut self,
         input_index: usize,
-        prevouts: &Prevouts,
-        sighash_type: SchnorrSigHashType,
+        prevouts: &Prevouts<T>,
+        sighash_type: SchnorrSighashType,
         genesis_hash: BlockHash,
     ) -> Result<TapSighashHash, Error> {
-        let mut enc = TapSighashHash::engine();
+        let mut enc = sha256t::Hash::engine();
         self.taproot_encode_signing_data_to(
             &mut enc,
             input_index,
@@ -457,38 +458,38 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
             sighash_type,
             genesis_hash,
         )?;
-        Ok(TapSighashHash::from_engine(enc))
+        Ok(TapSighashHash(enc.finalize()))
     }
 
     /// Compute the BIP341 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`].
-    pub fn taproot_script_spend_signature_hash<S: Into<TapLeafHash>>(
+    pub fn taproot_script_spend_signature_hash<S: Into<TapLeafHash>, T: Borrow<TxOut>>(
         &mut self,
         input_index: usize,
-        prevouts: &Prevouts,
+        prevouts: &Prevouts<T>,
         leaf_hash: S,
-        sighash_type: SchnorrSigHashType,
+        sighash_type: SchnorrSighashType,
         genesis_hash: BlockHash,
     ) -> Result<TapSighashHash, Error> {
-        let mut enc = TapSighashHash::engine();
+        let mut enc = sha256t::Hash::engine();
         self.taproot_encode_signing_data_to(
             &mut enc,
             input_index,
             prevouts,
             None,
-            Some((leaf_hash.into(), 0xFFFFFFFF)),
+            Some((leaf_hash.into(), 0xFFFF_FFFF)),
             sighash_type,
             genesis_hash
         )?;
-        Ok(TapSighashHash::from_engine(enc))
+        Ok(TapSighashHash(enc.finalize()))
     }
 
     /// Encode the BIP143 signing data for any flag type into a given object implementing a
-    /// std::io::Write trait.
+    /// `std::io::Write` trait.
     ///
-    /// *Warning* This does NOT attempt to support OP_CODESEPARATOR. In general
+    /// *Warning* This 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.
@@ -502,21 +503,21 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         input_index: usize,
         script_code: &Script,
         value: confidential::Value,
-        sighash_type: EcdsaSigHashType,
+        sighash_type: EcdsaSighashType,
     ) -> Result<(), encode::Error> {
-        let zero_hash = sha256d::Hash::all_zeros();
+        let zero_hash = [0u8; 32];
 
         let (sighash, anyone_can_pay) = sighash_type.split_anyonecanpay_flag();
 
         self.tx.version.consensus_encode(&mut writer)?;
 
-        if !anyone_can_pay {
-            self.segwit_cache().prevouts.consensus_encode(&mut writer)?;
-        } else {
+        if anyone_can_pay {
             zero_hash.consensus_encode(&mut writer)?;
+        } else {
+            self.segwit_cache().prevouts.consensus_encode(&mut writer)?;
         }
 
-        if !anyone_can_pay && sighash != EcdsaSigHashType::Single && sighash != EcdsaSigHashType::None {
+        if !anyone_can_pay && sighash != EcdsaSighashType::Single && sighash != EcdsaSighashType::None {
             self.segwit_cache().sequences.consensus_encode(&mut writer)?;
         } else {
             zero_hash.consensus_encode(&mut writer)?;
@@ -524,10 +525,10 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
 
         // Elements: Push the hash issuance zero hash as required
         // If required implement for issuance, but not necessary as of now
-        if !anyone_can_pay {
-            self.segwit_cache().issuances.consensus_encode(&mut writer)?;
-        } else {
+        if anyone_can_pay {
             zero_hash.consensus_encode(&mut writer)?;
+        } else {
+            self.segwit_cache().issuances.consensus_encode(&mut writer)?;
         }
 
         // input specific values
@@ -544,12 +545,12 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         }
 
         // hashoutputs
-        if sighash != EcdsaSigHashType::Single && sighash != EcdsaSigHashType::None {
+        if sighash != EcdsaSighashType::Single && sighash != EcdsaSighashType::None {
             self.segwit_cache().outputs.consensus_encode(&mut writer)?;
-        } else if sighash == EcdsaSigHashType::Single && input_index < self.tx.output.len() {
-            let mut single_enc = SigHash::engine();
+        } else if sighash == EcdsaSighashType::Single && input_index < self.tx.output.len() {
+            let mut single_enc = sha256d::Hash::engine();
             self.tx.output[input_index].consensus_encode(&mut single_enc)?;
-            SigHash::from_engine(single_enc).consensus_encode(&mut writer)?;
+            Sighash(single_enc.finalize()).consensus_encode(&mut writer)?;
         } else {
             zero_hash.consensus_encode(&mut writer)?;
         }
@@ -560,7 +561,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
     }
 
     /// Compute the segwitv0(BIP143) style sighash for any flag type.
-    /// *Warning* This does NOT attempt to support OP_CODESEPARATOR. In general
+    /// *Warning* This 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.
@@ -573,20 +574,20 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         input_index: usize,
         script_code: &Script,
         value: confidential::Value,
-        sighash_type: EcdsaSigHashType
-    ) -> SigHash {
-        let mut enc = SigHash::engine();
+        sighash_type: EcdsaSighashType
+    ) -> Sighash {
+        let mut enc = sha256d::Hash::engine();
         self.encode_segwitv0_signing_data_to(&mut enc, input_index, script_code, value, sighash_type)
             .expect("engines don't error");
-        SigHash::from_engine(enc)
+        Sighash(enc.finalize())
     }
 
     /// Encodes the signing data from which a signature hash for a given input index with a given
     /// sighash flag can be computed.  To actually produce a scriptSig, this hash needs to be run
-    /// through an ECDSA signer, the SigHashType appended to the resulting sig, and a script
+    /// through an ECDSA signer, the `SighashType` appended to the resulting sig, and a script
     /// written around this, but this is the general (and hard) part.
     ///
-    /// *Warning* This does NOT attempt to support OP_CODESEPARATOR. In general this would require
+    /// *Warning* This 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.
     ///
@@ -597,14 +598,14 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         mut writer: Write,
         input_index: usize,
         script_pubkey: &Script,
-        sighash_type: EcdsaSigHashType,
+        sighash_type: EcdsaSighashType,
     ) -> Result<(), encode::Error> {
         assert!(input_index < self.tx.input.len());  // Panic on OOB
 
         let (sighash, anyone_can_pay) = sighash_type.split_anyonecanpay_flag();
 
         // Special-case sighash_single bug because this is easy enough.
-        if sighash == EcdsaSigHashType::Single && input_index >= self.tx.output.len() {
+        if sighash == EcdsaSighashType::Single && input_index >= self.tx.output.len() {
             writer.write_all(&[1, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
@@ -636,7 +637,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
                     previous_output: input.previous_output,
                     is_pegin: input.is_pegin,
                     script_sig: if n == input_index { script_pubkey.clone() } else { Script::new() },
-                    sequence: if n != input_index && (sighash == EcdsaSigHashType::Single || sighash == EcdsaSigHashType::None) { Sequence::ZERO } else { input.sequence },
+                    sequence: if n != input_index && (sighash == EcdsaSighashType::Single || sighash == EcdsaSighashType::None) { Sequence::ZERO } else { input.sequence },
                     asset_issuance: input.asset_issuance,
                     witness: TxInWitness::default(),
                 });
@@ -644,15 +645,15 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         }
         // ..then all outputs
         tx.output = match sighash {
-            EcdsaSigHashType::All => self.tx.output.clone(),
-            EcdsaSigHashType::Single => {
+            EcdsaSighashType::All => self.tx.output.clone(),
+            EcdsaSighashType::Single => {
                 let output_iter = self.tx.output.iter()
                                       .take(input_index + 1)  // sign all outputs up to and including this one, but erase
                                       .enumerate()            // all of them except for this one
                                       .map(|(n, out)| if n == input_index { out.clone() } else { TxOut::default() });
                 output_iter.collect()
             }
-            EcdsaSigHashType::None => vec![],
+            EcdsaSighashType::None => vec![],
             _ => unreachable!()
         };
         // hash the result
@@ -670,11 +671,11 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
 
     /// Computes a signature hash for a given input index with a given sighash flag.
     /// To actually produce a scriptSig, this hash needs to be run through an
-    /// ECDSA signer, the SigHashType appended to the resulting sig, and a
+    /// ECDSA signer, the `SighashType` appended to the resulting sig, and a
     /// script written around this, but this is the general (and hard) part.
     /// Does not take a mutable reference because it does not do any caching.
     ///
-    /// *Warning* This does NOT attempt to support OP_CODESEPARATOR. In general
+    /// *Warning* This 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.
@@ -686,12 +687,12 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         &self,
         input_index: usize,
         script_pubkey: &Script,
-        sighash_type: EcdsaSigHashType,
-    ) -> SigHash {
-        let mut engine = SigHash::engine();
+        sighash_type: EcdsaSighashType,
+    ) -> Sighash {
+        let mut engine = sha256d::Hash::engine();
         self.encode_legacy_signing_data_to(&mut engine, input_index, script_pubkey, sighash_type)
             .expect("engines don't error");
-        SigHash::from_engine(engine)
+        Sighash(engine.finalize())
     }
 
     #[inline]
@@ -706,7 +707,7 @@ impl<R: Deref<Target = 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.input {
                 txin.previous_output
                     .consensus_encode(&mut enc_prevouts)
                     .unwrap();
@@ -717,14 +718,14 @@ impl<R: Deref<Target = 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.output {
                         txout.consensus_encode(&mut enc).unwrap();
                     }
                     sha256::Hash::from_engine(enc)
                 },
                 issuances: {
                     let mut enc = sha256::Hash::engine();
-                    for txin in tx.input.iter() {
+                    for txin in &tx.input {
                         if txin.has_issuance() {
                             txin.asset_issuance.consensus_encode(&mut enc).unwrap();
                         } else {
@@ -743,31 +744,31 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
         self.segwit_cache.get_or_insert_with(|| {
             let common_cache = Self::common_cache_minimal_borrow(common_cache, tx);
             SegwitCache {
-                prevouts: sha256d::Hash::from_inner(
-                    sha256::Hash::hash(&common_cache.prevouts).into_inner(),
+                prevouts: sha256d::Hash::from_byte_array(
+                    sha256::Hash::hash(common_cache.prevouts.as_ref()).to_byte_array(),
                 ),
-                sequences: sha256d::Hash::from_inner(
-                    sha256::Hash::hash(&common_cache.sequences).into_inner(),
+                sequences: sha256d::Hash::from_byte_array(
+                    sha256::Hash::hash(common_cache.sequences.as_ref()).to_byte_array(),
                 ),
-                outputs: sha256d::Hash::from_inner(
-                    sha256::Hash::hash(&common_cache.outputs).into_inner(),
+                outputs: sha256d::Hash::from_byte_array(
+                    sha256::Hash::hash(common_cache.outputs.as_ref()).to_byte_array(),
                 ),
-                issuances: sha256d::Hash::from_inner(
-                    sha256::Hash::hash(&common_cache.issuances).into_inner(),
+                issuances: sha256d::Hash::from_byte_array(
+                    sha256::Hash::hash(common_cache.issuances.as_ref()).to_byte_array(),
                 ),
             }
         })
     }
 
     #[inline]
-    fn taproot_cache(&mut self, prevouts: &[TxOut]) -> &TaprootCache {
+    fn taproot_cache<T: Borrow<TxOut>>(&mut self, prevouts: &[T]) -> &TaprootCache {
         Self::taproot_cache_minimal_borrow(&mut self.taproot_cache, &self.tx, prevouts)
     }
 
-    fn taproot_cache_minimal_borrow<'a>(
+    fn taproot_cache_minimal_borrow<'a, T: Borrow<TxOut>>(
         taproot_cache: &'a mut Option<TaprootCache>,
         tx: &R,
-        prevouts: &[TxOut],
+        prevouts: &[T],
     ) -> &'a TaprootCache {
         taproot_cache.get_or_insert_with(|| {
             let mut enc_asset_amounts = sha256::Hash::engine();
@@ -776,14 +777,15 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
             let mut enc_issuance_rangeproofs = sha256::Hash::engine();
             let mut enc_output_witnesses = sha256::Hash::engine();
             for prevout in prevouts {
-                prevout.asset.consensus_encode(&mut enc_asset_amounts).unwrap();
-                prevout.value.consensus_encode(&mut enc_asset_amounts).unwrap();
+                prevout.borrow().asset.consensus_encode(&mut enc_asset_amounts).unwrap();
+                prevout.borrow().value.consensus_encode(&mut enc_asset_amounts).unwrap();
                 prevout
+                    .borrow()
                     .script_pubkey
                     .consensus_encode(&mut enc_script_pubkeys)
                     .unwrap();
             }
-            for inp in tx.input.iter() {
+            for inp in &tx.input {
                 inp.outpoint_flag()
                     .consensus_encode(&mut enc_outpoint_flags).unwrap();
                 inp.witness.amount_rangeproof
@@ -792,7 +794,7 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
                     .consensus_encode(&mut enc_issuance_rangeproofs).unwrap();
             }
 
-            for out in tx.output.iter() {
+            for out in &tx.output {
                 out.witness.surjection_proof.consensus_encode(&mut enc_output_witnesses).unwrap();
                 out.witness.rangeproof.consensus_encode(&mut enc_output_witnesses).unwrap();
             }
@@ -807,29 +809,29 @@ impl<R: Deref<Target = Transaction>> SigHashCache<R> {
     }
 }
 
-impl<R: DerefMut<Target = Transaction>> SigHashCache<R> {
-    /// When the SigHashCache is initialized with a mutable reference to a transaction instead of a
+impl<R: DerefMut<Target = Transaction>> SighashCache<R> {
+    /// When the `SighashCache` is initialized with a mutable reference to a transaction instead of a
     /// regular reference, this method is available to allow modification to the witnesses.
     ///
     /// This allows in-line signing such as
     /// ```
-    /// use elements::{PackedLockTime, Transaction, EcdsaSigHashType};
-    /// use elements::sighash::SigHashCache;
+    /// use elements::{LockTime, Transaction, EcdsaSighashType};
+    /// use elements::sighash::SighashCache;
     /// use elements::Script;
     /// use elements::confidential;
     ///
-    /// let mut tx_to_sign = Transaction { version: 2, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() };
+    /// let mut tx_to_sign = Transaction { version: 2, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() };
     /// let input_count = tx_to_sign.input.len();
     ///
-    /// let mut sig_hasher = SigHashCache::new(&mut tx_to_sign);
+    /// let mut sig_hasher = SighashCache::new(&mut tx_to_sign);
     /// for inp in 0..input_count {
     ///     let prevout_script = Script::new();
-    ///     let _sighash = sig_hasher.segwitv0_sighash(inp, &prevout_script, confidential::Value::Explicit(42), EcdsaSigHashType::All);
+    ///     let _sighash = sig_hasher.segwitv0_sighash(inp, &prevout_script, confidential::Value::Explicit(42), EcdsaSighashType::All);
     ///     // ... sign the sighash
     ///     sig_hasher.witness_mut(inp).unwrap().push(Vec::new());
     /// }
     /// ```
-    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Vec<Vec<u8>>> {
+    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut crate::Witness> {
         self.tx.input.get_mut(input_index).map(|i| &mut i.witness.script_witness)
     }
 }
@@ -856,21 +858,21 @@ impl<'a> Annex<'a> {
 
     /// Returns the Annex bytes data (including first byte `0x50`)
     pub fn as_bytes(&self) -> &[u8] {
-        &*self.0
+        self.0
     }
 }
 
-impl<'a> Encodable for Annex<'a> {
+impl Encodable for Annex<'_> {
     fn consensus_encode<W: io::Write>(&self, writer: W) -> Result<usize, encode::Error> {
-        encode::consensus_encode_with_size(&self.0, writer)
+        encode::consensus_encode_with_size(self.0, writer)
     }
 }
 
 /// Hashtype of an input's signature, encoded in the last byte of the signature
 /// Fixed values so they can be casted as integer types for encoding
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub enum SchnorrSigHashType {
-    /// 0x0: Used when not explicitly specified, defaulting to [`SchnorrSigHashType::All`]
+pub enum SchnorrSighashType {
+    /// 0x0: Used when not explicitly specified, defaulting to [`SchnorrSighashType::All`]
     Default = 0x00,
     /// 0x1: Sign all outputs
     All = 0x01,
@@ -892,67 +894,67 @@ pub enum SchnorrSigHashType {
     Reserved = 0xFF,
 }
 
-serde_string_impl!(SchnorrSigHashType, "a SchnorrSigHashType data");
+serde_string_impl!(SchnorrSighashType, "a SchnorrSighashType data");
 
-impl SchnorrSigHashType {
+impl SchnorrSighashType {
     /// Break the sighash flag into the "real" sighash flag and the ANYONECANPAY boolean
-    pub fn split_anyonecanpay_flag(self) -> (SchnorrSigHashType, bool) {
+    pub fn split_anyonecanpay_flag(self) -> (SchnorrSighashType, bool) {
         match self {
-            SchnorrSigHashType::Default => (SchnorrSigHashType::Default, false),
-            SchnorrSigHashType::All => (SchnorrSigHashType::All, false),
-            SchnorrSigHashType::None => (SchnorrSigHashType::None, false),
-            SchnorrSigHashType::Single => (SchnorrSigHashType::Single, false),
-            SchnorrSigHashType::AllPlusAnyoneCanPay => (SchnorrSigHashType::All, true),
-            SchnorrSigHashType::NonePlusAnyoneCanPay => (SchnorrSigHashType::None, true),
-            SchnorrSigHashType::SinglePlusAnyoneCanPay => (SchnorrSigHashType::Single, true),
-            SchnorrSigHashType::Reserved => (SchnorrSigHashType::Reserved, false),
+            SchnorrSighashType::Default => (SchnorrSighashType::Default, false),
+            SchnorrSighashType::All => (SchnorrSighashType::All, false),
+            SchnorrSighashType::None => (SchnorrSighashType::None, false),
+            SchnorrSighashType::Single => (SchnorrSighashType::Single, false),
+            SchnorrSighashType::AllPlusAnyoneCanPay => (SchnorrSighashType::All, true),
+            SchnorrSighashType::NonePlusAnyoneCanPay => (SchnorrSighashType::None, true),
+            SchnorrSighashType::SinglePlusAnyoneCanPay => (SchnorrSighashType::Single, true),
+            SchnorrSighashType::Reserved => (SchnorrSighashType::Reserved, false),
         }
     }
 
-    /// Create a [`SchnorrSigHashType`] from raw u8
+    /// Create a [`SchnorrSighashType`] from raw u8
     pub fn from_u8(hash_ty: u8) -> Option<Self> {
         match hash_ty {
-            0x00 => Some(SchnorrSigHashType::Default),
-            0x01 => Some(SchnorrSigHashType::All),
-            0x02 => Some(SchnorrSigHashType::None),
-            0x03 => Some(SchnorrSigHashType::Single),
-            0x81 => Some(SchnorrSigHashType::AllPlusAnyoneCanPay),
-            0x82 => Some(SchnorrSigHashType::NonePlusAnyoneCanPay),
-            0x83 => Some(SchnorrSigHashType::SinglePlusAnyoneCanPay),
+            0x00 => Some(SchnorrSighashType::Default),
+            0x01 => Some(SchnorrSighashType::All),
+            0x02 => Some(SchnorrSighashType::None),
+            0x03 => Some(SchnorrSighashType::Single),
+            0x81 => Some(SchnorrSighashType::AllPlusAnyoneCanPay),
+            0x82 => Some(SchnorrSighashType::NonePlusAnyoneCanPay),
+            0x83 => Some(SchnorrSighashType::SinglePlusAnyoneCanPay),
             _x => None,
         }
     }
 }
 
-impl fmt::Display for SchnorrSigHashType {
+impl fmt::Display for SchnorrSighashType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
-            SchnorrSigHashType::Default => "SIGHASH_DEFAULT",
-            SchnorrSigHashType::All => "SIGHASH_ALL",
-            SchnorrSigHashType::None => "SIGHASH_NONE",
-            SchnorrSigHashType::Single => "SIGHASH_SINGLE",
-            SchnorrSigHashType::AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
-            SchnorrSigHashType::NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
-            SchnorrSigHashType::SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
-            SchnorrSigHashType::Reserved => "SIGHASH_RESERVED",
+            SchnorrSighashType::Default => "SIGHASH_DEFAULT",
+            SchnorrSighashType::All => "SIGHASH_ALL",
+            SchnorrSighashType::None => "SIGHASH_NONE",
+            SchnorrSighashType::Single => "SIGHASH_SINGLE",
+            SchnorrSighashType::AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
+            SchnorrSighashType::NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
+            SchnorrSighashType::SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
+            SchnorrSighashType::Reserved => "SIGHASH_RESERVED",
         };
         f.write_str(s)
     }
 }
 
-impl std::str::FromStr for SchnorrSigHashType {
+impl std::str::FromStr for SchnorrSighashType {
     type Err = SighashTypeParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "SIGHASH_DEFAULT" => Ok(SchnorrSigHashType::Default),
-            "SIGHASH_ALL" => Ok(SchnorrSigHashType::All),
-            "SIGHASH_NONE" => Ok(SchnorrSigHashType::None),
-            "SIGHASH_SINGLE" => Ok(SchnorrSigHashType::Single),
-            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(SchnorrSigHashType::AllPlusAnyoneCanPay),
-            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(SchnorrSigHashType::NonePlusAnyoneCanPay),
-            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(SchnorrSigHashType::SinglePlusAnyoneCanPay),
-            "SIGHASH_RESERVED" => Ok(SchnorrSigHashType::Reserved),
+            "SIGHASH_DEFAULT" => Ok(SchnorrSighashType::Default),
+            "SIGHASH_ALL" => Ok(SchnorrSighashType::All),
+            "SIGHASH_NONE" => Ok(SchnorrSighashType::None),
+            "SIGHASH_SINGLE" => Ok(SchnorrSighashType::Single),
+            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(SchnorrSighashType::AllPlusAnyoneCanPay),
+            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(SchnorrSighashType::NonePlusAnyoneCanPay),
+            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(SchnorrSighashType::SinglePlusAnyoneCanPay),
+            "SIGHASH_RESERVED" => Ok(SchnorrSighashType::Reserved),
             _ => Err(SighashTypeParseError{ unrecognized: s.to_owned() }),
         }
     }
@@ -963,18 +965,15 @@ impl std::str::FromStr for SchnorrSigHashType {
 mod tests{
     use super::*;
     use crate::encode::deserialize;
-    use bitcoin::hashes::hex::FromHex;
-    use bitcoin;
-
-    fn test_segwit_sighash(tx: &str, script: &str, input_index: usize, value: &str, hash_type: EcdsaSigHashType, expected_result: &str) {
-        let tx: Transaction = deserialize(&Vec::<u8>::from_hex(tx).unwrap()[..]).unwrap();
-        let script = Script::from(Vec::<u8>::from_hex(script).unwrap());
-        // A hack to parse sha256d strings are sha256 so that we don't reverse them...
-        let raw_expected = bitcoin::hashes::sha256::Hash::from_hex(expected_result).unwrap();
-        let expected_result = SigHash::from_slice(&raw_expected[..]).unwrap();
-
-        let mut cache = SigHashCache::new(&tx);
-        let value : confidential::Value = deserialize(&Vec::<u8>::from_hex(value).unwrap()[..]).unwrap();
+
+    fn test_segwit_sighash(tx: &str, script: &str, input_index: usize, value: &str, hash_type: EcdsaSighashType, expected_result: &str) {
+        let tx: Transaction = deserialize(&hex::decode_to_vec(tx).unwrap()).unwrap();
+        let script = Script::from(hex::decode_to_vec(script).unwrap());
+        let raw_expected = hex::decode_to_array(expected_result).unwrap();
+        let expected_result = Sighash::from_byte_array(raw_expected);
+
+        let mut cache = SighashCache::new(&tx);
+        let value : confidential::Value = deserialize(&hex::decode_to_vec(value).unwrap()).unwrap();
         let actual_result = cache.segwitv0_sighash(input_index, &script, value, hash_type);
         assert_eq!(actual_result, expected_result);
     }
@@ -982,31 +981,30 @@ mod tests{
     #[test]
     fn test_segwit_sighashes(){
         // generated by script(example_test.py) at https://github.com/sanket1729/elements/commit/8fb4eb9e6020adaf20f3ec25055ffa905ba5b5c4
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::All, "e201b4019129a03ca0304989731c6dccde232c854d86fce999b7411da1e90048");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::None, "bfc6599816673083334ae82ac3459a2d0fef478d3e580e3ae203a28347502cb4");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::Single, "4bc8546e32d31c5415444138184696e80f49e537a083bfcc89be2ab41d962e76");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::AllPlusAnyoneCanPay, "b70ba5f4a1c2c48cd7f2104b2baa6a5c97987eb560916d39a5d427deb8b1dc2a");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::NonePlusAnyoneCanPay, "6d6a4749c09ffd9a8df4c5de5d939325d896009e18f94bb095c9d7d695a8465e");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::SinglePlusAnyoneCanPay, "7fc34367b42bf0e2bb78d8c20f45a64b81b2d4fbb59cbff8649322f619e88a0f");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::All, "71141639d982f1a1a8901e32fb1a9e15a0ea168b37d33300a3c9619fc3767388");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::None, "00730922d0e1d55b4b5fffafd087b06aeb44c4cedb58d8e182cbb9b87382cddb");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::Single, "100063ea0923ef4432dd51c5756383530f28b31ffe9d50b59a11b94a63c84c78");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::AllPlusAnyoneCanPay, "e1c4ddf5f723759f7d99d4f162155119160b1c6b765fdbdb25aedb2059769b74");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::NonePlusAnyoneCanPay, "b0be275e0c69e89ef5c482fdf330038c3b2994ebce3e3639bb81456d15a95a7a");
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSigHashType::SinglePlusAnyoneCanPay, "27c293da7a0f08e161fa2a77aeefa6743c929905597b5bcb28f2015fe648aa0c");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::All, "e201b4019129a03ca0304989731c6dccde232c854d86fce999b7411da1e90048");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::None, "bfc6599816673083334ae82ac3459a2d0fef478d3e580e3ae203a28347502cb4");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::Single, "4bc8546e32d31c5415444138184696e80f49e537a083bfcc89be2ab41d962e76");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::AllPlusAnyoneCanPay, "b70ba5f4a1c2c48cd7f2104b2baa6a5c97987eb560916d39a5d427deb8b1dc2a");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::NonePlusAnyoneCanPay, "6d6a4749c09ffd9a8df4c5de5d939325d896009e18f94bb095c9d7d695a8465e");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::SinglePlusAnyoneCanPay, "7fc34367b42bf0e2bb78d8c20f45a64b81b2d4fbb59cbff8649322f619e88a0f");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::All, "71141639d982f1a1a8901e32fb1a9e15a0ea168b37d33300a3c9619fc3767388");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::None, "00730922d0e1d55b4b5fffafd087b06aeb44c4cedb58d8e182cbb9b87382cddb");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::Single, "100063ea0923ef4432dd51c5756383530f28b31ffe9d50b59a11b94a63c84c78");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::AllPlusAnyoneCanPay, "e1c4ddf5f723759f7d99d4f162155119160b1c6b765fdbdb25aedb2059769b74");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::NonePlusAnyoneCanPay, "b0be275e0c69e89ef5c482fdf330038c3b2994ebce3e3639bb81456d15a95a7a");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "010000000005f5e100", EcdsaSighashType::SinglePlusAnyoneCanPay, "27c293da7a0f08e161fa2a77aeefa6743c929905597b5bcb28f2015fe648aa0c");
 
         // Test a issuance test with only sighash all
-        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e801000000000000000a0201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSigHashType::All, "ea946ee417d5a16a1038b2c3b54d1b7b12a9f98c0dcb4684bf005eb1c27d0c92");
+        test_segwit_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e801000000000000000a0201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, "0850863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352", EcdsaSighashType::All, "ea946ee417d5a16a1038b2c3b54d1b7b12a9f98c0dcb4684bf005eb1c27d0c92");
     }
 
 
-    fn test_legacy_sighash(tx: &str, script: &str, input_index: usize, hash_type: EcdsaSigHashType, expected_result: &str) {
-        let tx: Transaction = deserialize(&Vec::<u8>::from_hex(tx).unwrap()[..]).unwrap();
-        let script = Script::from(Vec::<u8>::from_hex(script).unwrap());
-        // A hack to parse sha256d strings are sha256 so that we don't reverse them...
-        let raw_expected = bitcoin::hashes::sha256::Hash::from_hex(expected_result).unwrap();
-        let expected_result = SigHash::from_slice(&raw_expected[..]).unwrap();
-        let sighash_cache = SigHashCache::new(&tx);
+    fn test_legacy_sighash(tx: &str, script: &str, input_index: usize, hash_type: EcdsaSighashType, expected_result: &str) {
+        let tx: Transaction = deserialize(&hex::decode_to_vec(tx).unwrap()).unwrap();
+        let script = Script::from(hex::decode_to_vec(script).unwrap());
+        let raw_expected = hex::decode_to_array(expected_result).unwrap();
+        let expected_result = Sighash::from_byte_array(raw_expected);
+        let sighash_cache = SighashCache::new(&tx);
         let actual_result = sighash_cache.legacy_sighash(input_index, &script, hash_type);
         assert_eq!(actual_result, expected_result);
     }
@@ -1014,14 +1012,14 @@ mod tests{
     #[test]
     fn test_legacy_sighashes(){
         // generated by script(example_test.py) at https://github.com/sanket1729/elements/commit/5ddfb5a749e85b71c961d29d5689d692ef7cee4b
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::All, "769ad754a77282712895475eb17251bcb8f3cc35dc13406fa1188ef2707556cf");
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::None, "b399ca018b4fec7d94e47092b72d25983db2d0d16eaa6a672050add66077ef40");
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::Single, "4efef74996f840ed104c0b69461f33da2e364288f3015c55b2516a68e3ee60bc");
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::AllPlusAnyoneCanPay, "a70a59ae29f1d9f4461f12e730e5cb75d3a75312666e8d911584aebb8e4afc5c");
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::NonePlusAnyoneCanPay, "5f3694a35f3b994639d3fb1f6214ec166f9e0721c7ab3f216e465b9b2728d834");
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::SinglePlusAnyoneCanPay, "4c18486c473dc31c264c477c55e9c17d70fddb9f567c7d411ce922261577167c");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::All, "769ad754a77282712895475eb17251bcb8f3cc35dc13406fa1188ef2707556cf");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::None, "b399ca018b4fec7d94e47092b72d25983db2d0d16eaa6a672050add66077ef40");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::Single, "4efef74996f840ed104c0b69461f33da2e364288f3015c55b2516a68e3ee60bc");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::AllPlusAnyoneCanPay, "a70a59ae29f1d9f4461f12e730e5cb75d3a75312666e8d911584aebb8e4afc5c");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::NonePlusAnyoneCanPay, "5f3694a35f3b994639d3fb1f6214ec166f9e0721c7ab3f216e465b9b2728d834");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af0000000000000000000201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::SinglePlusAnyoneCanPay, "4c18486c473dc31c264c477c55e9c17d70fddb9f567c7d411ce922261577167c");
 
         // Test a issuance test with only sighash all
-        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e801000000000000000a0201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSigHashType::All, "9f00e1758a230aaf6c9bce777701a604f50b2ac5f2a07e1cd478d8a0e70fc195");
+        test_legacy_sighash("010000000001715df5ccebaf02ff18d6fae7263fa69fed5de59c900f4749556eba41bc7bf2af000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000003e801000000000000000a0201230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000124101100001f5175517551755175517551755175517551755175517551755175517551755101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e100000000000000", "76a914f54a5851e9372b87810a8e60cdd2e7cfd80b6e3188ac", 0, EcdsaSighashType::All, "9f00e1758a230aaf6c9bce777701a604f50b2ac5f2a07e1cd478d8a0e70fc195");
     }
 }
diff --git a/src/slip77.rs b/src/slip77.rs
deleted file mode 100644
index a162f217..00000000
--- a/src/slip77.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! Implemenation of SLIP-0077: Deterministic blinding key derivation
-//! for Confidential Transactions
-//!
-//! Spec: https://github.com/satoshilabs/slips/blob/master/slip-0077.md
-
-use bitcoin::hashes::{Hash, HashEngine, hmac, sha256, sha256d};
-use secp256k1_zkp;
-use slip21;
-
-use crate::Script;
-
-const SLIP77_DERIVATION: &str = "SLIP-0077";
-
-/// A SLIP-77 master blinding key used to derive shared blinding keys.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MasterBlindingKey(pub secp256k1_zkp::SecretKey);
-
-impl MasterBlindingKey {
-    /// Create a new master blinding key from a seed.
-    pub fn new(seed: &[u8]) -> MasterBlindingKey {
-        let master = slip21::Node::new_master(&seed);
-        let child = master.derive_child(&SLIP77_DERIVATION.as_bytes());
-        let key = child.key();
-        assert_eq!(key.len(), 32);
-        MasterBlindingKey(secp256k1_zkp::SecretKey::from_slice(key).expect("len is 32"))
-    }
-
-    /// Derive a blinding private key for a given scriptPubkey.
-    pub fn derive_blinding_key(&self, script_pubkey: &Script) -> secp256k1_zkp::SecretKey {
-        let mut engine: hmac::HmacEngine<sha256::Hash> = hmac::HmacEngine::new(&self.0[..]);
-        engine.input(script_pubkey.as_bytes());
-
-        let bytes = hmac::Hmac::<sha256::Hash>::from_engine(engine).into_inner();
-        secp256k1_zkp::SecretKey::from_slice(&bytes[..]).expect("len is 32")
-    }
-
-    /// Derive a shared nonce for a given scriptPubkey and a blinding pubkey.
-    /// This is the same as performing ECDH with the secret key that [derive_blinding_key] returns.
-    pub fn derive_shared_nonce(&self,
-        script_pubkey: &Script,
-        other: &secp256k1_zkp::PublicKey,
-    ) -> sha256d::Hash {
-        let blinding_private_key = self.derive_blinding_key(script_pubkey);
-        let shared_secret = secp256k1_zkp::ecdh::SharedSecret::new(&other, &blinding_private_key);
-        sha256d::Hash::hash(shared_secret.as_ref())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::str::FromStr;
-
-    use secp256k1_zkp::SecretKey;
-    use bitcoin::hashes::hex::FromHex;
-
-    use crate::address::Address;
-
-    #[test]
-    fn test_slip77() {
-        //! Test vector from libwally.
-
-        let seed_hex = "731e9b42eb9774f8a6b51af35a06f6ef1cdb6cf04402163ceacf0c8bace2831a";
-        let master = MasterBlindingKey::new(&Vec::<u8>::from_hex(&seed_hex).unwrap());
-
-        let privkey_hex = "c2f338e32ad1a2bd9cac569e67728163bf4c326a1770ec2293ba65548a581e97";
-        let privkey = SecretKey::from_slice(&Vec::<u8>::from_hex(privkey_hex).unwrap()).unwrap();
-        assert_eq!(master.0, privkey);
-
-        let scriptpk_hex = "a914afa92d77cd3541b443771649572db096cf49bf8c87";
-        let scriptpk: Script = Vec::<u8>::from_hex(&scriptpk_hex).unwrap().into();
-
-        let blindingkey_hex = "02b067c374bb56c54c016fae29218c000ada60f81ef45b4aeebbeb24931bb8bc";
-        let blindingkey = SecretKey::from_slice(&Vec::<u8>::from_hex(blindingkey_hex).unwrap()).unwrap();
-        assert_eq!(master.derive_blinding_key(&scriptpk), blindingkey);
-    }
-
-    #[test]
-    fn test_slip77_libwally() {
-        //! test vectors taken from libwally-core
-        //! test_confidential_addr.py test_master_blinding_key
-        let seed_hex = "c76c4ac4f4e4a00d6b274d5c39c700bb4a7ddc04fbc6f78e85ca75007b5b495f74a9043eeb77bdd53aa6fc3a0e31462270316fa04b8c19114c8798706cd02ac8";
-        let master_blinding_key = MasterBlindingKey::new(&Vec::<u8>::from_hex(&seed_hex).unwrap());
-
-        let script: Script = Vec::<u8>::from_hex(
-            "76a914a579388225827d9f2fe9014add644487808c695d88ac").unwrap().into();
-        let blinding_key = master_blinding_key.derive_blinding_key(&script);
-        let secp = secp256k1_zkp::Secp256k1::new();
-        let public_key = secp256k1_zkp::PublicKey::from_secret_key(&secp, &blinding_key);
-        let unconfidential_addr = Address::from_str("2dpWh6jbhAowNsQ5agtFzi7j6nKscj6UnEr").unwrap();
-        let conf_addr = unconfidential_addr.to_confidential(public_key);
-        assert_eq!(conf_addr.to_string(),
-            "CTEkf75DFff5ReB7juTg2oehrj41aMj21kvvJaQdWsEAQohz1EDhu7Ayh6goxpz3GZRVKidTtaXaXYEJ"
-        );
-    }
-}
diff --git a/src/taproot.rs b/src/taproot.rs
index 890d7582..4bffd3fd 100644
--- a/src/taproot.rs
+++ b/src/taproot.rs
@@ -16,110 +16,106 @@
 use std::cmp::Reverse;
 use std::{error, io, fmt};
 
-use crate::hashes::{sha256, sha256t, Hash};
+use crate::hashes::HashEngine as _;
 use crate::schnorr::{UntweakedPublicKey, TweakedPublicKey, TapTweak};
 use crate::Script;
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap};
+use hashes::{sha256, sha256t};
 use secp256k1_zkp::{self, Secp256k1, Scalar};
-use crate::hashes::HashEngine;
 use crate::encode::Encodable;
 
-/// The SHA-256 midstate value for the TapLeaf/elements hash.
-const MIDSTATE_TAPLEAF: [u8; 32] = [
-    185, 165, 93, 95, 240, 236, 34, 5, 36, 232, 194, 245, 220, 195, 78, 19, 172,
-    0, 50, 118, 247, 82, 182, 211, 91, 67, 107, 156, 165, 45, 235, 183
-];
-// (rev) b7eb2da59c6b435bd3b652f7763200ac134ec3dcf5c2e8240522ecf05f5da5b9
-
-/// The SHA-256 midstate value for the TapBranch hash.
-const MIDSTATE_TAPBRANCH: [u8; 32] = [
-    252, 158, 245, 135, 52, 103, 176, 127, 235, 57, 57, 126, 85, 222, 151, 33, 244,
-    104, 173, 199, 58, 32, 119, 252, 160, 87, 213, 147, 185, 136, 180, 140
-];
-// (rev) 8cb488b993d557a0fc77203ac7ad68f42197de557e3939eb7fb0673487f59efc
-
-/// The SHA-256 midstate value for the TapTweak hash.
-const MIDSTATE_TAPTWEAK: [u8; 32] = [
-    7, 183, 63, 121, 138, 46, 7, 245, 251, 66, 173, 40, 201, 174, 109, 157, 27, 32,
-    0, 107, 144, 33, 8, 203, 198, 48, 213, 13, 252, 12, 251, 9
-];
-// (rev) 09fb0cfc0dd530c6cb0821906b00201b9d6daec928ad42fbf5072e8a793fb707
-
-/// The SHA-256 midstate value for the TapSigHash hash.
-const MIDSTATE_TAPSIGHASH: [u8; 32] = [
-    166, 230, 6, 120, 41, 228, 53, 167, 211, 20, 34, 171, 34, 191, 116, 23, 134,
-    105, 138, 238, 229, 146, 92, 206, 255, 57, 14, 164, 52, 159, 126, 13
-];
-// (rev) 0d7e9f34a40e39ffce5c92e5ee8a69861774bf22ab2214d3a735e4297806e6a6
-
-/// Internal macro to speficy the different taproot tagged hashes.
-macro_rules! sha256t_hash_newtype {
-    ($newtype:ident, $tag:ident, $midstate:ident, $midstate_len:expr, $docs:meta, $reverse: expr) => {
-        sha256t_hash_newtype!($newtype, $tag, $midstate, $midstate_len, $docs, $reverse, stringify!($newtype));
-    };
-
-    ($newtype:ident, $tag:ident, $midstate:ident, $midstate_len:expr, $docs:meta, $reverse: expr, $sname:expr) => {
-        #[doc = "The tag used for ["]
-        #[doc = $sname]
-        #[doc = "]"]
-        pub struct $tag;
-
-        impl sha256t::Tag for $tag {
-            fn engine() -> sha256::HashEngine {
-                let midstate = sha256::Midstate::from_inner($midstate);
-                sha256::HashEngine::from_midstate(midstate, $midstate_len)
-            }
-        }
 
-        hash_newtype!($newtype, sha256t::Hash<$tag>, 32, $docs, $reverse);
-    };
+/// The tag for tapleaves.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapLeafTag;
+
+/// The tag for tapbranches.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapBranchTag;
+
+/// The tag for taptweaks.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapTweakTag;
+
+/// The tag for Taproot sighashes.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapSighashTag;
+
+impl sha256t::Tag for TapLeafTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapLeaf/elements");
+}
+
+impl sha256t::Tag for TapBranchTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapBranch/elements");
+}
+
+impl sha256t::Tag for TapTweakTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapTweak/elements");
+}
+
+impl sha256t::Tag for TapSighashTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapSighash/elements");
 }
 
 // Taproot test vectors from BIP-341 state the hashes without any reversing
-sha256t_hash_newtype!(TapLeafHash, TapLeafTag, MIDSTATE_TAPLEAF, 64,
-    doc="Taproot-tagged hash for elements tapscript Merkle tree leafs", false
-);
-sha256t_hash_newtype!(TapBranchHash, TapBranchTag, MIDSTATE_TAPBRANCH, 64,
-    doc="Taproot-tagged hash for elements tapscript Merkle tree branches", false
-);
-sha256t_hash_newtype!(TapTweakHash, TapTweakTag, MIDSTATE_TAPTWEAK, 64,
-    doc="Taproot-tagged hash for elements public key tweaks", false
-);
-sha256t_hash_newtype!(TapSighashHash, TapSighashTag, MIDSTATE_TAPSIGHASH, 64,
-    doc="Taproot-tagged hash for the elements taproot signature hash", false
-);
+hashes::hash_newtype! {
+    /// Taproot-tagged hash for elements tapscript Merkle tree leafs.
+    pub struct TapLeafHash(sha256t::Hash::<TapLeafTag>);
+
+    /// Tagged hash used in taproot trees; see BIP-340 for tagging rules.
+    pub struct TapNodeHash(sha256t::Hash::<TapBranchTag>);
+
+    /// Taproot-tagged hash for elements public key tweaks.
+    pub struct TapTweakHash(sha256t::Hash::<TapTweakTag>);
+
+    /// Taproot-tagged hash for the elements taproot signature hash.
+    pub struct TapSighashHash(pub(crate) sha256t::Hash::<TapSighashTag>);
+}
+
+hashes::impl_hex_for_newtype!(TapLeafHash, TapNodeHash, TapTweakHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(TapLeafHash, TapNodeHash, TapTweakHash);
+// We do not implement serde or display/fromstr for 'Sighash'. In general it's dangerous
+// to deserialize sighashes; they must be the output of a cryptographic hash function.
+hashes::impl_debug_only_for_newtype!(TapSighashHash);
 
 impl TapTweakHash {
 
     /// Create a new BIP341 [`TapTweakHash`] from key and tweak
-    /// Produces H_taptweak(P||R) where P is internal key and R is the merkle root
+    /// Produces `H_taptweak(P||R)` where P is internal key and R is the merkle root
     pub fn from_key_and_tweak(
         internal_key: UntweakedPublicKey,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
     ) -> TapTweakHash {
-        let mut eng = TapTweakHash::engine();
+        let mut eng = sha256t::Hash::engine();
         // always hash the key
         eng.input(&internal_key.serialize());
         if let Some(h) = merkle_root {
-            eng.input(&h);
+            eng.input(h.as_ref());
         } else {
             // nothing to hash
         }
-        TapTweakHash::from_engine(eng)
+        TapTweakHash(eng.finalize())
+    }
+
+    /// Converts a `TapTweakHash` into a `Scalar` ready for use with key tweaking API.
+    pub fn to_scalar(self) -> Scalar {
+        // This is statistically extremely unlikely to panic.
+        Scalar::from_be_bytes(self.to_byte_array()).expect("hash value greater than curve order")
     }
 }
 
 impl TapLeafHash {
     /// function to compute leaf hash from components
     pub fn from_script(script: &Script, ver: LeafVersion) -> TapLeafHash {
-        let mut eng = TapLeafHash::engine();
+        let mut eng = sha256t::Hash::engine();
         ver.as_u8()
             .consensus_encode(&mut eng)
             .expect("engines don't error");
         script
             .consensus_encode(&mut eng)
             .expect("engines don't error");
-        TapLeafHash::from_engine(eng)
+        TapLeafHash(eng.finalize())
     }
 }
 
@@ -140,12 +136,13 @@ pub const TAPROOT_CONTROL_MAX_SIZE: usize =
 // type alias for versioned tap script corresponding merkle proof
 type ScriptMerkleProofMap = BTreeMap<(Script, LeafVersion), BTreeSet<TaprootMerkleBranch>>;
 /// Data structure for representing Taproot spending information.
+///
 /// Taproot output corresponds to a combination of a
 /// single public key condition (known the internal key), and zero or more
 /// general conditions encoded in scripts organized in the form of a binary tree.
 ///
 /// Taproot can be spent be either:
-/// - Spending using the key path i.e., with secret key corresponding to the output_key
+/// - Spending using the key path i.e., with secret key corresponding to the `output_key`
 /// - By satisfying any of the scripts in the script spent path. Each script can be satisfied by providing
 ///   a witness stack consisting of the script's inputs, plus the script itself and the control block.
 ///
@@ -160,12 +157,12 @@ pub struct TaprootSpendInfo {
     /// The BIP341 internal key.
     internal_key: UntweakedPublicKey,
     /// The Merkle root of the script tree (None if there are no scripts)
-    merkle_root: Option<TapBranchHash>,
+    merkle_root: Option<TapNodeHash>,
     /// The sign final output pubkey as per BIP 341
     output_key_parity: secp256k1_zkp::Parity,
     /// The tweaked output key
     output_key: TweakedPublicKey,
-    /// Map from (script, leaf_version) to (sets of) [`TaprootMerkleBranch`].
+    /// Map from (script, `leaf_version`) to (sets of) [`TaprootMerkleBranch`].
     /// More than one control block for a given script is only possible if it
     /// appears in multiple branches of the tree. In all cases, keeping one should
     /// be enough for spending funds, but we keep all of the paths so that
@@ -180,7 +177,7 @@ impl TaprootSpendInfo {
     /// constructing the tree as a Huffman tree is the optimal way to minimize average
     /// case satisfaction cost. This function takes input an iterator of tuple(u64, &Script)
     /// where usize represents the satisfaction weights of the branch.
-    /// For example, [(3, S1), (2, S2), (5, S3)] would construct a TapTree that has optimal
+    /// 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%.
     ///
     /// # Errors:
@@ -203,7 +200,7 @@ impl TaprootSpendInfo {
     {
         let mut node_weights = BinaryHeap::<(Reverse<u64>, NodeInfo)>::new();
         for (p, leaf) in script_weights {
-            node_weights.push((Reverse(p as u64), NodeInfo::new_leaf_with_ver(leaf, LeafVersion::default())));
+            node_weights.push((Reverse(u64::from(p)), NodeInfo::new_leaf_with_ver(leaf, LeafVersion::default())));
         }
         if node_weights.is_empty() {
             return Err(TaprootBuilderError::IncompleteTree);
@@ -223,11 +220,11 @@ impl TaprootSpendInfo {
         // Therefore, the loop will eventually terminate with exactly 1 element
         debug_assert!(node_weights.len() == 1);
         let node = node_weights.pop().expect("huffman tree algorithm is broken").1;
-        return Ok(Self::from_node_info(secp, internal_key, node));
+        Ok(Self::from_node_info(secp, internal_key, node))
     }
 
     /// Create a new key spend with internal key and proided merkle root.
-    /// Provide [`None`] for merkle_root if there is no script path.
+    /// Provide [`None`] for `merkle_root` if there is no script path.
     ///
     /// *Note*: As per BIP341
     ///
@@ -241,19 +238,19 @@ impl TaprootSpendInfo {
     pub fn new_key_spend<C: secp256k1_zkp::Verification>(
         secp: &Secp256k1<C>,
         internal_key: UntweakedPublicKey,
-        merkle_root: Option<TapBranchHash>,
+        merkle_root: Option<TapNodeHash>,
     ) -> Self {
         let (output_key, parity) = internal_key.tap_tweak(secp, merkle_root);
         Self {
-            internal_key: internal_key,
-            merkle_root: merkle_root,
+            internal_key,
+            merkle_root,
             output_key_parity: parity,
-            output_key: output_key,
+            output_key,
             script_map: BTreeMap::new(),
         }
     }
 
-    /// Obtain the tweak and parity used to compute the output_key
+    /// Obtain the tweak and parity used to compute the `output_key`
     pub fn tap_tweak(&self) -> TapTweakHash {
         TapTweakHash::from_key_and_tweak(self.internal_key, self.merkle_root)
     }
@@ -264,7 +261,7 @@ impl TaprootSpendInfo {
     }
 
     /// Obtain the merkle root
-    pub fn merkle_root(&self) -> Option<TapBranchHash> {
+    pub fn merkle_root(&self) -> Option<TapNodeHash> {
         self.merkle_root
     }
 
@@ -286,21 +283,18 @@ impl TaprootSpendInfo {
         node: NodeInfo,
     ) -> TaprootSpendInfo {
         // Create as if it is a key spend path with the given merkle root
-        let root_hash = Some(TapBranchHash::from_inner(node.hash.into_inner()));
+        let root_hash = Some(TapNodeHash::from_byte_array(node.hash.to_byte_array()));
         let mut info = TaprootSpendInfo::new_key_spend(secp, internal_key, root_hash);
         for leaves in node.leaves {
             let key = (leaves.script, leaves.ver);
             let value = leaves.merkle_branch;
-            match info.script_map.get_mut(&key) {
-                Some(set) => {
-                    set.insert(value);
-                    continue; // NLL fix
-                }
-                None => {}
+            if let Some(set) = info.script_map.get_mut(&key) {
+                set.insert(value);
+            } else {
+                let mut set = BTreeSet::new();
+                set.insert(value);
+                info.script_map.insert(key, set);
             }
-            let mut set = BTreeSet::new();
-            set.insert(value);
-            info.script_map.insert(key, set);
         }
         info
     }
@@ -312,7 +306,7 @@ impl TaprootSpendInfo {
 
     /// Obtain a [`ControlBlock`] for particular script with the given version.
     /// Returns [`None`] if the script is not contained in the [`TaprootSpendInfo`]
-    /// If there are multiple ControlBlocks possible, this returns the shortest one.
+    /// If there are multiple `ControlBlocks` possible, this returns the shortest one.
     pub fn control_block(&self, script_ver: &(Script, LeafVersion)) -> Option<ControlBlock> {
         let merkle_branch_set = self.script_map.get(script_ver)?;
         // Choose the smallest one amongst the multiple script maps
@@ -332,8 +326,8 @@ impl TaprootSpendInfo {
 /// Builder for building taproot iteratively. Users can specify tap leaf or omitted/hidden
 /// branches in a DFS(Depth first search) walk to construct this tree.
 // Similar to Taproot Builder in bitcoin core
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TaprootBuilder {
     // The following doc-comment is from bitcoin core, but modified for rust
     // The comment below describes the current state of the builder for a given tree.
@@ -412,7 +406,7 @@ impl TaprootBuilder {
     /// Add a hidden/omitted node at a depth `depth` to the builder.
     /// This will error if the node are not provided in a DFS walk order. The depth of the
     /// root node is 0 and it's immediate child would be at depth 1.
-    pub fn add_hidden(self, depth: usize, hash: sha256::Hash) -> Result<Self, TaprootBuilderError> {
+    pub fn add_hidden(self, depth: usize, hash: TapNodeHash) -> Result<Self, TaprootBuilderError> {
         let node = NodeInfo::new_hidden(hash);
         self.insert(node, depth)
     }
@@ -473,7 +467,7 @@ impl TaprootBuilder {
             // add enough nodes so that we can insert node at depth `depth`
             let num_extra_nodes = depth + 1 - self.branch.len();
             self.branch
-                .extend((0..num_extra_nodes).into_iter().map(|_| None));
+                .extend((0..num_extra_nodes).map(|_| None));
         }
         // Push the last node to the branch
         self.branch[depth] = Some(node);
@@ -483,24 +477,24 @@ impl TaprootBuilder {
 
 /// Structure to represent the node information in taproot tree
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NodeInfo {
     /// Merkle Hash for this node
-    pub(crate) hash: sha256::Hash,
+    pub(crate) hash: TapNodeHash,
     /// information about leaves inside this node
     pub(crate) leaves: Vec<LeafInfo>,
 }
 
 impl NodeInfo {
-    /// Creates a new NodeInfo with omitted/hidden info
-    pub fn new_hidden(hash: sha256::Hash) -> Self {
+    /// Creates a new `NodeInfo` with omitted/hidden info
+    pub fn new_hidden(hash: TapNodeHash) -> Self {
         Self {
-            hash: hash,
+            hash,
             leaves: vec![],
         }
     }
 
-    /// Creates a new leaf with NodeInfo
+    /// Creates a new leaf with `NodeInfo`
     pub fn new_leaf_with_ver(script: Script, ver: LeafVersion) -> Self {
         let leaf = LeafInfo::new(script, ver);
         Self {
@@ -509,7 +503,7 @@ impl NodeInfo {
         }
     }
 
-    /// Combines two NodeInfo's to create a new parent
+    /// Combines two `NodeInfo`'s to create a new parent
     pub fn combine(a: Self, b: Self) -> Result<Self, TaprootBuilderError> {
         let mut all_leaves = Vec::with_capacity(a.leaves.len() + b.leaves.len());
         for mut a_leaf in a.leaves {
@@ -520,16 +514,16 @@ impl NodeInfo {
             b_leaf.merkle_branch.push(a.hash)?; // add hashing partner
             all_leaves.push(b_leaf);
         }
-        let mut eng = TapBranchHash::engine();
+        let mut eng = sha256t::Hash::engine();
         if a.hash < b.hash {
-            eng.input(&a.hash);
-            eng.input(&b.hash);
+            eng.input(a.hash.as_ref());
+            eng.input(b.hash.as_ref());
         } else {
-            eng.input(&b.hash);
-            eng.input(&a.hash);
+            eng.input(b.hash.as_ref());
+            eng.input(a.hash.as_ref());
         };
         Ok(Self {
-            hash: sha256::Hash::from_engine(eng),
+            hash: TapNodeHash(eng.finalize()),
             leaves: all_leaves,
         })
     }
@@ -537,7 +531,7 @@ impl NodeInfo {
 
 /// Data Structure to store information about taproot leaf node
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct LeafInfo {
     // The underlying script
     pub(crate) script: Script,
@@ -551,30 +545,29 @@ impl LeafInfo {
     /// Creates an instance of Self from Script with default version and no merkle branch
     pub fn new(script: Script, ver: LeafVersion) -> Self {
         Self {
-            script: script,
-            ver: ver,
+            script,
+            ver,
             merkle_branch: TaprootMerkleBranch(vec![]),
         }
     }
 
     // Computes a leaf hash for the given leaf
-    fn hash(&self) -> sha256::Hash {
+    fn hash(&self) -> TapNodeHash {
         let leaf_hash = TapLeafHash::from_script(&self.script, self.ver);
-        sha256::Hash::from_inner(leaf_hash.into_inner())
+        TapNodeHash::from_byte_array(leaf_hash.to_byte_array())
     }
 }
 
 /// The Merkle proof for inclusion of a tree in a taptree hash
 // The type of hash is sha256::Hash because the vector might contain
-// both TapBranchHash and TapLeafHash
+// both TapNodeHash and TapLeafHash
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
-pub struct TaprootMerkleBranch(Vec<sha256::Hash>);
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct TaprootMerkleBranch(Vec<TapNodeHash>);
 
 impl TaprootMerkleBranch {
     /// Obtain a reference to inner
-    pub fn as_inner(&self) -> &[sha256::Hash] {
+    pub fn as_inner(&self) -> &[TapNodeHash] {
         &self.0
     }
 
@@ -588,11 +581,12 @@ impl TaprootMerkleBranch {
             ))
         } else {
             let inner = sl
-                // TODO: Use chunks_exact after MSRV changes to 1.31
-                .chunks(TAPROOT_CONTROL_NODE_SIZE)
+                // TODO: Use array_chunks after this stabilizes
+                .chunks_exact(TAPROOT_CONTROL_NODE_SIZE)
                 .map(|chunk| {
-                    sha256::Hash::from_slice(chunk)
-                        .expect("chunk exact always returns the correct size")
+                    use core::convert::TryFrom as _;
+                    let chunk = <&[u8; 32]>::try_from(chunk).expect("need array_chunks in stdlib");
+                    TapNodeHash::from_byte_array(*chunk)
                 })
                 .collect();
             Ok(TaprootMerkleBranch(inner))
@@ -602,19 +596,19 @@ impl TaprootMerkleBranch {
     /// Serialize to a writer. Returns the number of bytes written
     pub fn encode<Write: io::Write>(&self, mut writer: Write) -> io::Result<usize> {
         let mut written = 0;
-        for hash in self.0.iter() {
-            written += writer.write(hash)?;
+        for hash in &self.0 {
+            written += writer.write(hash.as_ref())?;
         }
         Ok(written)
     }
 
     /// Serialize self as bytes
     pub fn serialize(&self) -> Vec<u8> {
-        self.0.iter().map(|e| e.as_inner()).flatten().map(|x| *x).collect::<Vec<u8>>()
+        self.0.iter().flat_map(TapNodeHash::as_byte_array).copied().collect::<Vec<u8>>()
     }
 
     // Internal function to append elements to proof
-    fn push(&mut self, h: sha256::Hash) -> Result<(), TaprootBuilderError> {
+    fn push(&mut self, h: TapNodeHash) -> Result<(), TaprootBuilderError> {
         if self.0.len() >= TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(TaprootBuilderError::InvalidMerkleTreeDepth(self.0.len()))
         } else {
@@ -623,9 +617,12 @@ impl TaprootMerkleBranch {
         }
     }
 
-    /// Create a MerkleProof from Vec<[`sha256::Hash`]>. Returns an error when
-    /// inner proof len is more than TAPROOT_CONTROL_MAX_NODE_COUNT (128)
-    pub fn from_inner(inner: Vec<sha256::Hash>) -> Result<Self, TaprootError> {
+    /// Create a `MerkleProof` from Vec<[`TapNodeHash`]>.
+    ///
+    /// # Errors
+    ///
+    /// Errors if inner proof len is more than `TAPROOT_CONTROL_MAX_NODE_COUNT` (128)
+    pub fn from_inner(inner: Vec<TapNodeHash>) -> Result<Self, TaprootError> {
         if inner.len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(TaprootError::InvalidMerkleTreeDepth(inner.len()))
         } else {
@@ -633,15 +630,15 @@ impl TaprootMerkleBranch {
         }
     }
 
-    /// Consume Self to get Vec<[`sha256::Hash`]>
-    pub fn into_inner(self) -> Vec<sha256::Hash> {
+    /// Consume Self to get Vec<[`TapNodeHash`]>
+    pub fn into_inner(self) -> Vec<TapNodeHash> {
         self.0
     }
 }
 
 /// Control Block data structure used in Tapscript satisfaction
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ControlBlock {
     /// The tapleaf version,
     pub leaf_version: LeafVersion,
@@ -654,14 +651,14 @@ pub struct ControlBlock {
 }
 
 impl ControlBlock {
-    /// Obtain a ControlBlock from slice. This is an extra witness element
+    /// Obtain a `ControlBlock` from slice. This is an extra witness element
     /// that provides the proof that taproot script pubkey is correctly computed
     /// with some specified leaf hash. This is the last element in
     /// taproot witness when spending a output via script path.
     ///
     /// # Errors:
     /// - If the control block size is not of the form 33 + 32m where
-    /// 0 <= m <= 128, InvalidControlBlock is returned
+    ///   0 <= m <= 128, `InvalidControlBlock` is returned
     pub fn from_slice(sl: &[u8]) -> Result<ControlBlock, TaprootError> {
         if sl.len() < TAPROOT_CONTROL_BASE_SIZE
             || (sl.len() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE != 0
@@ -683,7 +680,7 @@ impl ControlBlock {
     }
 
     /// Obtain the size of control block. Faster and more efficient than calling
-    /// serialize() followed by len(). Can be handy for fee estimation
+    /// `serialize()` followed by `len()`. Can be handy for fee estimation
     pub fn size(&self) -> usize {
         TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * self.merkle_branch.as_inner().len()
     }
@@ -699,8 +696,8 @@ impl ControlBlock {
     }
 
     /// Serialize 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
+    /// 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.
     pub fn serialize(&self) -> Vec<u8> {
         let mut buf = Vec::with_capacity(self.size());
@@ -720,24 +717,24 @@ impl ControlBlock {
     ) -> bool {
         // compute the script hash
         // Initially the curr_hash is the leaf hash
-        let leaf_hash = TapLeafHash::from_script(&script, self.leaf_version);
-        let mut curr_hash = TapBranchHash::from_inner(leaf_hash.into_inner());
+        let leaf_hash = TapLeafHash::from_script(script, self.leaf_version);
+        let mut curr_hash = TapNodeHash::from_byte_array(leaf_hash.to_byte_array());
         // Verify the proof
         for elem in self.merkle_branch.as_inner() {
-            let mut eng = TapBranchHash::engine();
-            if curr_hash.as_inner() < elem.as_inner() {
-                eng.input(&curr_hash);
-                eng.input(elem);
+            let mut eng = sha256t::Hash::engine();
+            if curr_hash.as_byte_array() < elem.as_byte_array() {
+                eng.input(curr_hash.as_ref());
+                eng.input(elem.as_ref());
             } else {
-                eng.input(elem);
-                eng.input(&curr_hash);
+                eng.input(elem.as_ref());
+                eng.input(curr_hash.as_ref());
             }
             // Recalculate the curr hash as parent hash
-            curr_hash = TapBranchHash::from_engine(eng);
+            curr_hash = TapNodeHash(eng.finalize());
         }
         // compute the taptweak
         let tweak = TapTweakHash::from_key_and_tweak(self.internal_key, Some(curr_hash));
-        let tweak = Scalar::from_be_bytes(tweak.into_inner()).expect("hash value greater than curve order");
+        let tweak = Scalar::from_be_bytes(tweak.to_byte_array()).expect("hash value greater than curve order");
 
         self.internal_key.tweak_add_check(
             secp,
@@ -750,7 +747,7 @@ impl ControlBlock {
 
 /// The leaf version for tapleafs
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct LeafVersion(u8);
 
 impl Default for LeafVersion {
@@ -760,8 +757,11 @@ impl Default for LeafVersion {
 }
 
 impl LeafVersion {
-    /// Obtain LeafVersion from u8, will error when last bit of ver is even or
-    /// when ver is 0x50 (ANNEX_TAG)
+    /// The leaf version used for Tapscript branches.
+    pub const TAPSCRIPT: Self = Self(TAPROOT_LEAF_TAPSCRIPT);
+
+    /// Obtain `LeafVersion` from u8, will error when last bit of ver is even or
+    /// when ver is 0x50 (`ANNEX_TAG`)
     // Text from BIP341:
     // In order to support some forms of static analysis that rely on
     // being able to identify script spends without access to the output being
@@ -779,15 +779,15 @@ impl LeafVersion {
         }
     }
 
-    /// Get the inner version from LeafVersion
+    /// Get the inner version from `LeafVersion`
     pub fn as_u8(&self) -> u8 {
         self.0
     }
 }
 
-impl Into<u8> for LeafVersion {
-    fn into(self) -> u8 {
-        self.0
+impl From<LeafVersion> for u8 {
+    fn from(lv: LeafVersion) -> u8 {
+        lv.0
     }
 }
 
@@ -852,7 +852,7 @@ pub enum TaprootError {
     InvalidControlBlockSize(usize),
     /// Invalid taproot internal key
     InvalidInternalKey(secp256k1_zkp::UpstreamError),
-    /// Empty TapTree
+    /// Empty `TapTree`
     EmptyTree,
 }
 
@@ -891,43 +891,23 @@ impl error::Error for TaprootError {}
 #[cfg(test)]
 mod tests{
     use super::*;
-    use crate::hashes::HashEngine;
-    use crate::hashes::sha256t::Tag;
-    use crate::hashes::hex::FromHex;
+    use crate::hashes::{sha256, HashEngine};
     use std::str::FromStr;
 
     fn tag_engine(tag_name: &str) -> sha256::HashEngine {
         let mut engine = sha256::Hash::engine();
         let tag_hash = sha256::Hash::hash(tag_name.as_bytes());
-        engine.input(&tag_hash[..]);
-        engine.input(&tag_hash[..]);
+        engine.input(tag_hash.as_byte_array());
+        engine.input(tag_hash.as_byte_array());
         engine
     }
 
     #[test]
-    fn test_midstates() {
-        // check midstate against hard-coded values
-        assert_eq!(MIDSTATE_TAPLEAF, tag_engine("TapLeaf/elements").midstate().into_inner());
-        assert_eq!(MIDSTATE_TAPBRANCH, tag_engine("TapBranch/elements").midstate().into_inner());
-        assert_eq!(MIDSTATE_TAPTWEAK, tag_engine("TapTweak/elements").midstate().into_inner());
-        assert_eq!(MIDSTATE_TAPSIGHASH, tag_engine("TapSighash/elements").midstate().into_inner());
-
-        // test that engine creation roundtrips
-        assert_eq!(tag_engine("TapLeaf/elements").midstate(), TapLeafTag::engine().midstate());
-        assert_eq!(tag_engine("TapBranch/elements").midstate(), TapBranchTag::engine().midstate());
-        assert_eq!(tag_engine("TapTweak/elements").midstate(), TapTweakTag::engine().midstate());
-        assert_eq!(tag_engine("TapSighash/elements").midstate(), TapSighashTag::engine().midstate());
-
-        // check that hash creation is the same as building into the same engine
-        fn empty_hash(tag_name: &str) -> [u8; 32] {
-            let mut e = tag_engine(tag_name);
-            e.input(&[]);
-            sha256::Hash::from_engine(e).into_inner()
-        }
-        assert_eq!(empty_hash("TapLeaf/elements"), TapLeafHash::hash(&[]).into_inner());
-        assert_eq!(empty_hash("TapBranch/elements"), TapBranchHash::hash(&[]).into_inner());
-        assert_eq!(empty_hash("TapTweak/elements"), TapTweakHash::hash(&[]).into_inner());
-        assert_eq!(empty_hash("TapSighash/elements"), TapSighashHash::hash(&[]).into_inner());
+    fn test_engine_initialization() {
+        assert_eq!(tag_engine("TapLeaf/elements").finalize().to_byte_array(), sha256t::Hash::<TapLeafTag>::engine().finalize().to_byte_array());
+        assert_eq!(tag_engine("TapBranch/elements").finalize().to_byte_array(), sha256t::Hash::<TapBranchTag>::engine().finalize().to_byte_array());
+        assert_eq!(tag_engine("TapTweak/elements").finalize().to_byte_array(), sha256t::Hash::<TapTweakTag>::engine().finalize().to_byte_array());
+        assert_eq!(tag_engine("TapSighash/elements").finalize().to_byte_array(), sha256t::Hash::<TapSighashTag>::engine().finalize().to_byte_array());
     }
 
     #[test]
@@ -936,11 +916,11 @@ mod tests{
         let internal_key = UntweakedPublicKey::from_str("93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51").unwrap();
 
         let script_weights = vec![
-            (10, Script::from_hex("51").unwrap()), // semantics of script don't matter for this test
-            (20, Script::from_hex("52").unwrap()),
-            (20, Script::from_hex("53").unwrap()),
-            (30, Script::from_hex("54").unwrap()),
-            (19, Script::from_hex("55").unwrap()),
+            (10, Script::from_hex_no_prefix("51").unwrap()), // semantics of script don't matter for this test
+            (20, Script::from_hex_no_prefix("52").unwrap()),
+            (20, Script::from_hex_no_prefix("53").unwrap()),
+            (30, Script::from_hex_no_prefix("54").unwrap()),
+            (19, Script::from_hex_no_prefix("55").unwrap()),
         ];
         let tree_info = TaprootSpendInfo::with_huffman_tree(&secp, internal_key, script_weights.clone()).unwrap();
 
@@ -954,12 +934,12 @@ mod tests{
          *   3            55 51
          */
 
-        for (script, length) in vec![("51", 3), ("52", 2), ("53", 2), ("54", 2), ("55", 3)] {
+        for &(script, length) in &[("51", 3), ("52", 2), ("53", 2), ("54", 2), ("55", 3)] {
             assert_eq!(
                 length,
                 tree_info
                     .script_map
-                    .get(&(Script::from_hex(script).unwrap(), LeafVersion::default()))
+                    .get(&(Script::from_hex_no_prefix(script).unwrap(), LeafVersion::default()))
                     .expect("Present Key")
                     .iter()
                     .next()
@@ -976,7 +956,7 @@ mod tests{
         for (_weights, script) in script_weights {
             let ver_script = (script, LeafVersion::default());
             let ctrl_block = tree_info.control_block(&ver_script).unwrap();
-            assert!(ctrl_block.verify_taproot_commitment(&secp, &output_key, &ver_script.0))
+            assert!(ctrl_block.verify_taproot_commitment(&secp, &output_key, &ver_script.0));
         }
     }
 
@@ -995,24 +975,27 @@ mod tests{
         //                                   /  \    /  \
         //                                  A    B  C  / \
         //                                            D   E
-        let a = Script::from_hex("51").unwrap();
-        let b = Script::from_hex("52").unwrap();
-        let c = Script::from_hex("53").unwrap();
-        let d = Script::from_hex("54").unwrap();
-        let e = Script::from_hex("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();
-        let builder = builder.add_leaf(3, e.clone()).unwrap();
+        let scripts = [
+            Script::from_hex_no_prefix("51").unwrap(),
+            Script::from_hex_no_prefix("52").unwrap(),
+            Script::from_hex_no_prefix("53").unwrap(),
+            Script::from_hex_no_prefix("54").unwrap(),
+            Script::from_hex_no_prefix("55").unwrap(),
+        ];
+        let builder = builder
+            .add_leaf(2, scripts[0].clone()).unwrap()
+            .add_leaf(2, scripts[1].clone()).unwrap()
+            .add_leaf(2, scripts[2].clone()).unwrap()
+            .add_leaf(3, scripts[3].clone()).unwrap()
+            .add_leaf(3, scripts[4].clone()).unwrap();
 
         let tree_info = builder.finalize(&secp, internal_key).unwrap();
         let output_key = tree_info.output_key();
 
-        for script in vec![a, b, c, d, e] {
+        for script in scripts {
             let ver_script = (script, LeafVersion::default());
             let ctrl_block = tree_info.control_block(&ver_script).unwrap();
-            assert!(ctrl_block.verify_taproot_commitment(&secp, &output_key, &ver_script.0))
+            assert!(ctrl_block.verify_taproot_commitment(&secp, &output_key, &ver_script.0));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/transaction/decoders.rs b/src/transaction/decoders.rs
new file mode 100644
index 00000000..26df90e7
--- /dev/null
+++ b/src/transaction/decoders.rs
@@ -0,0 +1,522 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Transaction Decoders
+//!
+//! These are encapsulated because there are many of them, but in the end we
+//! only expose the top-level ones outside of this module.
+
+use core::fmt;
+
+use super::{
+    AssetIssuance, OutPoint, Script, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness,
+    Txid,
+};
+use crate::confidential::{RangeProofDecoder, RangeProofDecoderError};
+use crate::encoding::{
+    ArrayDecoder, Decode, Decoder, Decoder2, Decoder2Error, Decoder3, Decoder4, Decoder4Error,
+    DecoderStatus, UnexpectedEofError, VecDecoder,
+};
+use crate::locktime::{LockTime, LockTimeDecoder};
+use crate::{PeginWitnessDecoder, PeginWitnessDecoderError, WitnessDecoder, WitnessDecoderError};
+
+/// Decoder for the [`OutPoint`] type.
+///
+/// This is a non-public struct and we do not implement [`Decode`] for [`OutPoint`]
+/// because we can't actually encode/decode outpoints independently of the rest of
+/// a [`TxIn`]. This is because we mask bits into the vout of the outpoint.
+#[derive(Default)]
+struct OutPointDecoder {
+    inner: Decoder2<ArrayDecoder<32>, ArrayDecoder<4>>,
+}
+
+/// Decoder error for the [`OutPoint`] type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct OutPointDecoderError(Decoder2Error<UnexpectedEofError, UnexpectedEofError>);
+
+impl fmt::Display for OutPointDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("error decoding outpoint")
+    }
+}
+
+impl std::error::Error for OutPointDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+impl Decoder for OutPointDecoder {
+    type Output = OutPoint;
+    type Error = OutPointDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(OutPointDecoderError)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (txid, vout) = self.inner.end().map_err(OutPointDecoderError)?;
+        Ok(OutPoint { txid: Txid::from_byte_array(txid), vout: u32::from_le_bytes(vout) })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`Sequence`] type.
+    #[derive(Default)]
+    pub struct SequenceDecoder(ArrayDecoder<4>);
+
+    /// Decoder error for the [`Sequence`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct SequenceDecoderError(UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding sequence";
+
+    impl Decode for Sequence {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(Sequence::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`AssetIssuance`] type.
+    #[derive(Default)]
+    pub struct AssetIssuanceDecoder(Decoder4<
+        crate::AssetBlindingNonceDecoder,
+        crate::AssetEntropyDecoder,
+        crate::confidential::ValueDecoder,
+        crate::confidential::ValueDecoder,
+    >);
+    /// Decoder error for the [`AssetIssuance`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetIssuanceDecoderError(Decoder4Error<
+        crate::AssetBlindingNonceDecoderError,
+        crate::AssetEntropyDecoderError,
+        crate::confidential::ValueDecoderError,
+        crate::confidential::ValueDecoderError,
+    >);
+    const ERROR_DISPLAY = "error decoding asset issuance";
+
+    impl Decode for AssetIssuance {
+        fn convert_inner(output) -> Result<_, AssetIssuanceDecoderError> {
+            let (asset_blinding_nonce, asset_entropy, amount, inflation_keys) = output;
+            Ok(AssetIssuance {
+                asset_blinding_nonce,
+                asset_entropy,
+                amount,
+                inflation_keys,
+            })
+        }
+    }
+}
+
+decoder_state_machine! {
+    /// Decoder for the [`TxIn`] type.
+    pub struct TxInDecoder(enum TxInDecoderInner {
+        Done(TxIn),
+        Errored,
+        Initial {
+            decoder: Decoder3<
+                OutPointDecoder,
+                crate::script::ScriptDecoder,
+                SequenceDecoder,
+            >,
+            => transition_initial(output, ...) -> Result {
+                let (mut outpoint, script_sig, sequence) = output;
+                let (is_pegin, has_issuance) = if outpoint.vout == 0xffff_ffff {
+                    (false, false)
+                } else {
+                    let vout = outpoint.vout;
+                    outpoint.vout &= !((1 << 30) | (1 << 31));
+                    (vout & (1 << 30) != 0, vout & (1 << 31) != 0)
+                };
+                if has_issuance {
+                    Ok(TxInDecoderInner::AssetIssuance {
+                        decoder: AssetIssuanceDecoder::default(),
+                        outpoint, script_sig, sequence, is_pegin,
+                    })
+                } else {
+                    if outpoint.vout != 0xffff_ffff {
+                        outpoint.vout &= !((1 << 30) | (1 << 31));
+                    }
+                    Ok(TxInDecoderInner::Done(TxIn {
+                        previous_output: outpoint,
+                        is_pegin,
+                        script_sig,
+                        sequence,
+                        asset_issuance: AssetIssuance::null(),
+                        witness: TxInWitness::default(),
+                    }))
+                }
+            }
+        },
+        AssetIssuance {
+            decoder: AssetIssuanceDecoder,
+            outpoint: OutPoint,
+            script_sig: Script,
+            sequence: Sequence,
+            is_pegin: bool
+            => transition_asset_issuance(asset_issuance, ...) -> Result {
+                if asset_issuance.is_null() {
+                    return Err(TxInDecoderErrorInner::SuperfluousIssuance);
+                }
+
+                Ok(TxInDecoderInner::Done(TxIn {
+                    previous_output: outpoint,
+                    is_pegin,
+                    script_sig,
+                    sequence,
+                    asset_issuance,
+                    witness: TxInWitness::default(),
+                }))
+            }
+        },
+    });
+
+    /// Decoder error for the [`TxIn`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxInDecoderError(enum TxInDecoderErrorInner {
+        [macro-inserted decoder variants]
+        SuperfluousIssuance,
+    });
+}
+
+impl Default for TxInDecoder {
+    fn default() -> Self { Self(TxInDecoderInner::Initial { decoder: Decoder3::default() }) }
+}
+
+impl fmt::Display for TxInDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(..) => f.write_str("error decoding outpoint, scriptsig or sequence"),
+            Inner::AssetIssuance(..) => f.write_str("error decoding asset issuance"),
+            Inner::SuperfluousIssuance =>
+                f.write_str("input had issuance flag set, but null issuance"),
+        }
+    }
+}
+
+impl std::error::Error for TxInDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(ref e) => Some(e),
+            Inner::AssetIssuance(ref e) => Some(e),
+            Inner::SuperfluousIssuance => None,
+        }
+    }
+}
+
+/// Decoder for the [`TxInWitness`] type.
+#[derive(Default)]
+pub struct TxInWitnessDecoder {
+    inner: Decoder4<RangeProofDecoder, RangeProofDecoder, WitnessDecoder, PeginWitnessDecoder>,
+}
+
+/// Decoder error for the [`TxInWitness`] type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TxInWitnessDecoderError(
+    Decoder4Error<
+        RangeProofDecoderError,
+        RangeProofDecoderError,
+        WitnessDecoderError,
+        PeginWitnessDecoderError,
+    >,
+);
+
+impl fmt::Display for TxInWitnessDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("error decoding transaction input witness")
+    }
+}
+
+impl std::error::Error for TxInWitnessDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+impl Decoder for TxInWitnessDecoder {
+    type Output = TxInWitness;
+    type Error = TxInWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(TxInWitnessDecoderError)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness) =
+            self.inner.end().map_err(TxInWitnessDecoderError)?;
+
+        Ok(TxInWitness {
+            amount_rangeproof,
+            inflation_keys_rangeproof,
+            script_witness,
+            pegin_witness,
+        })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+impl Decode for TxInWitness {
+    type Decoder = TxInWitnessDecoder;
+}
+
+/// An decoder for the witnesses in a sequence of [`TxIn`]s.
+///
+/// Comsumes a vec of [`TxIn`]s on construction and then yields that
+/// same vector, with the witness fields overwritten.
+#[derive(Default)]
+struct TxInWitnessesDecoder {
+    txins: Vec<TxIn>,
+    index: usize,
+    // Invariant: if this is Some then
+    decoder: Option<TxInWitnessDecoder>,
+}
+
+impl TxInWitnessesDecoder {
+    fn new(txins: Vec<TxIn>) -> Self { Self { txins, index: 0, decoder: None } }
+}
+
+impl Decoder for TxInWitnessesDecoder {
+    type Output = Vec<TxIn>;
+    type Error = TxInWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        loop {
+            let Some(next_txin) = self.txins.get_mut(self.index) else {
+                return Ok(DecoderStatus::Ready);
+            };
+
+            let mut decoder = self.decoder.take().unwrap_or_else(TxInWitness::decoder);
+            if decoder.push_bytes(bytes)?.needs_more() {
+                self.decoder = Some(decoder);
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            next_txin.witness = decoder.end()?;
+            self.index += 1;
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        loop {
+            let Some(last_txin) = self.txins.get_mut(self.index) else {
+                return Ok(self.txins);
+            };
+
+            last_txin.witness = self.decoder.take().unwrap_or_else(TxInWitness::decoder).end()?;
+            self.index += 1;
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        self.decoder.as_ref().map_or(0, TxInWitnessDecoder::read_limit)
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`TxOutWitness`] type.
+    #[derive(Default)]
+    pub struct TxOutWitnessDecoder(Decoder2<
+        crate::confidential::SurjectionProofDecoder,
+        crate::confidential::RangeProofDecoder,
+    >);
+
+    /// Decoder error for the [`TxOutWitness`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxOutWitnessDecoderError(Decoder2Error<
+        crate::confidential::SurjectionProofDecoderError,
+        crate::confidential::RangeProofDecoderError,
+    >);
+    const ERROR_DISPLAY = "error decoding transaction output witness";
+
+    impl Decode for TxOutWitness {
+        fn convert_inner(output) -> Result<_, TxOutWitnessDecoderErrorInner> {
+            let (surjection_proof, rangeproof) = output;
+            Ok(TxOutWitness {surjection_proof, rangeproof })
+        }
+    }
+}
+
+/// An decoder for the witnesses in a sequence of [`TxOut`]s.
+///
+/// Comsumes a vec of [`TxOut`]s on construction and then yields that
+/// same vector, with the witness fields overwritten.
+#[derive(Default)]
+struct TxOutWitnessesDecoder {
+    txouts: Vec<TxOut>,
+    index: usize,
+    // Invariant: if this is Some then
+    decoder: Option<TxOutWitnessDecoder>,
+}
+
+impl TxOutWitnessesDecoder {
+    fn new(txouts: Vec<TxOut>) -> Self { Self { txouts, index: 0, decoder: None } }
+}
+
+impl Decoder for TxOutWitnessesDecoder {
+    type Output = Vec<TxOut>;
+    type Error = TxOutWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        loop {
+            let Some(next_txout) = self.txouts.get_mut(self.index) else {
+                return Ok(DecoderStatus::Ready);
+            };
+
+            let mut decoder = self.decoder.take().unwrap_or_else(TxOutWitness::decoder);
+            if decoder.push_bytes(bytes)?.needs_more() {
+                self.decoder = Some(decoder);
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            next_txout.witness = decoder.end()?;
+            self.index += 1;
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        loop {
+            let Some(last_txout) = self.txouts.get_mut(self.index) else {
+                return Ok(self.txouts);
+            };
+
+            last_txout.witness = self.decoder.take().unwrap_or_else(TxOutWitness::decoder).end()?;
+            self.index += 1;
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        self.decoder.as_ref().map_or(0, TxOutWitnessDecoder::read_limit)
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`TxOut`] type.
+    #[derive(Default)]
+    pub struct TxOutDecoder(Decoder4<
+        crate::confidential::AssetDecoder,
+        crate::confidential::ValueDecoder,
+        crate::confidential::NonceDecoder,
+        crate::script::ScriptDecoder,
+    >);
+
+
+    /// Decoder error for the [`TxOut`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxOutDecoderError(Decoder4Error<
+            crate::confidential::AssetDecoderError,
+            crate::confidential::ValueDecoderError,
+            crate::confidential::NonceDecoderError,
+            crate::script::ScriptDecoderError,
+    >);
+    const ERROR_DISPLAY = "error decoding transaction output witness";
+
+    impl Decode for TxOut {
+        fn convert_inner(output) -> Result<_, TxOutDecoderErrorInner> {
+            let (asset, value, nonce, script_pubkey) = output;
+            Ok(TxOut { asset, value, nonce, script_pubkey, witness: TxOutWitness::empty() })
+        }
+    }
+}
+
+decoder_state_machine! {
+    /// Decoder for the [`Transaction`] type.
+    pub struct TransactionDecoder(enum TransactionDecoderInner {
+        Done(Transaction),
+        Errored,
+        DecodingNonWitness {
+            decoder: Decoder4<
+                ArrayDecoder<4>,
+                ArrayDecoder<1>,
+                Decoder2<
+                    VecDecoder<TxIn>,
+                    VecDecoder<TxOut>,
+                >,
+                LockTimeDecoder,
+            >,
+            => transition_non_witness(output, ...) -> Result {
+                let (version, wit_flag, (input, output), lock_time) = output;
+                match wit_flag {
+                    [0] => Ok(TransactionDecoderInner::Done(Transaction {
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                        input,
+                        output,
+                    })),
+                    [1] => Ok(TransactionDecoderInner::DecodingWitnesses {
+                        decoder: Decoder2::new(
+                            TxInWitnessesDecoder::new(input),
+                            TxOutWitnessesDecoder::new(output),
+                        ),
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                    }),
+                    [x] => Err(TransactionDecoderErrorInner::InvalidWitnessFlag(x)),
+                }
+            }
+        },
+        DecodingWitnesses {
+            decoder: Decoder2<
+                TxInWitnessesDecoder,
+                TxOutWitnessesDecoder,
+            >,
+            version: u32,
+            lock_time: LockTime
+            => transition_witnesses(output, ...) -> Result {
+                let (input, output) = output;
+                if input.iter().all(|input| input.witness.is_empty()) &&
+                    output.iter().all(|output| output.witness.is_empty()) {
+                    Err(TransactionDecoderErrorInner::NoWitnesses)
+                } else {
+                    Ok(TransactionDecoderInner::Done(Transaction {
+                        version,
+                        lock_time,
+                        input,
+                        output,
+                    }))
+                }
+            }
+        },
+    });
+
+    /// Decoder error for the [`Transaction`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TransactionDecoderError(enum TransactionDecoderErrorInner {
+        [macro-inserted decoder variants]
+        InvalidWitnessFlag(u8),
+        NoWitnesses,
+    });
+}
+
+impl Default for TransactionDecoder {
+    fn default() -> Self {
+        Self(TransactionDecoderInner::DecodingNonWitness { decoder: Decoder4::default() })
+    }
+}
+
+impl fmt::Display for TransactionDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(..) =>
+                f.write_str("failed to decode non-witness part of transaction"),
+            Inner::DecodingWitnesses(..) => f.write_str("failed to decode transaction witnesses"),
+            Inner::InvalidWitnessFlag(flag) => {
+                write!(f, "invalid witness flag {flag} (must be 0 or 1)")
+            }
+            Inner::NoWitnesses => f.write_str("witness flag set but all witnesses were empty"),
+        }
+    }
+}
+
+impl std::error::Error for TransactionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(ref e) => Some(e),
+            Inner::DecodingWitnesses(ref e) => Some(e),
+            Inner::InvalidWitnessFlag(_) => None,
+            Inner::NoWitnesses => None,
+        }
+    }
+}
diff --git a/src/transaction/encoders.rs b/src/transaction/encoders.rs
new file mode 100644
index 00000000..0dc6164d
--- /dev/null
+++ b/src/transaction/encoders.rs
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Transaction Encoders
+//!
+//! These are encapsulated because there are many of them, but in the end we
+//! only expose the top-level ones outside of this module.
+
+use super::{AssetIssuance, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness};
+use crate::confidential::RangeProofEncoder;
+use crate::encoding::{
+    encoder_newtype, encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder,
+    Encoder2, Encoder4, Encoder6, EncoderStatus, PrefixedSliceEncoder,
+};
+use crate::locktime::LockTimeEncoder;
+use crate::{PeginWitnessEncoder, WitnessEncoder};
+
+// While we define an [`OutPointEncoder`] struct, we don't actually implement `Encode` or `Decode`
+// for [`OutPoint`], since the outpoint encoding depends on pegin/issuance data from the rest of
+// the txin. We just use it as a private building block.
+
+encoder_newtype_exact! {
+    /// Encoder for the [`OutPoint`] type.
+    #[derive(Clone, Debug)]
+    struct OutPointEncoder<'e>(Encoder2<
+        ArrayRefEncoder<'e, 32>,
+        ArrayEncoder<4>,
+    >);
+}
+
+impl<'e> OutPointEncoder<'e> {
+    fn from_txin(txin: &'e TxIn) -> Self {
+        let mut vout = txin.previous_output.vout;
+        if txin.is_pegin {
+            vout |= 1 << 30;
+        }
+        if txin.has_issuance() {
+            vout |= 1 << 31;
+        }
+
+        Self::new(Encoder2::new(
+            ArrayRefEncoder::without_length_prefix(txin.previous_output.txid.as_byte_array()),
+            ArrayEncoder::without_length_prefix(vout.to_le_bytes()),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`Sequence`] type.
+    #[derive(Clone, Debug)]
+    pub struct SequenceEncoder<'e>(ArrayEncoder<4>);
+}
+
+impl Encode for Sequence {
+    type Encoder<'e> = SequenceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        SequenceEncoder::new(ArrayEncoder::without_length_prefix(
+            self.to_consensus_u32().to_le_bytes(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`AssetIssuance`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetIssuanceEncoder<'e>(Encoder4<
+        crate::AssetBlindingNonceEncoder<'e>,
+        crate::AssetEntropyEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+    >);
+}
+
+impl Encode for AssetIssuance {
+    type Encoder<'e> = AssetIssuanceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetIssuanceEncoder::new(Encoder4::new(
+            self.asset_blinding_nonce.encoder(),
+            self.asset_entropy.encoder(),
+            self.amount.encoder(),
+            self.inflation_keys.encoder(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxInWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxInWitnessEncoder<'e>(Encoder4<
+        RangeProofEncoder<'e>,
+        RangeProofEncoder<'e>,
+        WitnessEncoder<'e>,
+        PeginWitnessEncoder<'e>,
+    >);
+}
+
+impl Encode for TxInWitness {
+    type Encoder<'e> = TxInWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxInWitnessEncoder::new(Encoder4::new(
+            self.amount_rangeproof.encoder(),
+            self.inflation_keys_rangeproof.encoder(),
+            self.script_witness.encoder(),
+            self.pegin_witness.encoder(),
+        ))
+    }
+}
+
+/// An encoder for the witnesses in a sequence of [`TxIn`]s.
+#[derive(Clone, Debug)]
+struct TxInWitnessesEncoder<'e> {
+    txins: &'e [TxIn],
+    cur_enc: Option<TxInWitnessEncoder<'e>>,
+}
+
+impl<'e> TxInWitnessesEncoder<'e> {
+    fn new(txins: &'e [TxIn]) -> Self {
+        Self { txins, cur_enc: txins.first().map(|txin| txin.witness.encoder()) }
+    }
+}
+
+impl Encoder for TxInWitnessesEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        self.cur_enc.as_ref().map(Encoder::current_chunk).unwrap_or_default()
+    }
+
+    fn advance(&mut self) -> EncoderStatus {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return EncoderStatus::Finished;
+        };
+
+        loop {
+            if cur.advance().has_more() {
+                return EncoderStatus::HasMore;
+            }
+            // self.inputs guaranteed to be non-empty if cur_enc is non-None.
+            self.txins = &self.txins[1..];
+            if let Some(txin) = self.txins.first() {
+                *cur = txin.witness.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return EncoderStatus::HasMore;
+                }
+            } else {
+                self.cur_enc = None;
+                return EncoderStatus::Finished;
+            }
+        }
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxIn`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxInEncoder<'e>(Encoder4<
+        OutPointEncoder<'e>,
+        crate::script::ScriptEncoder<'e>,
+        SequenceEncoder<'e>,
+        Option<AssetIssuanceEncoder<'e>>,
+    >);
+}
+
+impl Encode for TxIn {
+    type Encoder<'e> = TxInEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxInEncoder::new(Encoder4::new(
+            OutPointEncoder::from_txin(self),
+            self.script_sig.encoder(),
+            self.sequence.encoder(),
+            self.has_issuance().then(|| self.asset_issuance.encoder()),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxOutWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxOutWitnessEncoder<'e>(Encoder2<
+        crate::confidential::SurjectionProofEncoder<'e>,
+        crate::confidential::RangeProofEncoder<'e>,
+    >);
+}
+
+impl Encode for TxOutWitness {
+    type Encoder<'e> = TxOutWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxOutWitnessEncoder::new(Encoder2::new(
+            self.surjection_proof.encoder(),
+            self.rangeproof.encoder(),
+        ))
+    }
+}
+
+/// An encoder for the witnesses in a sequence of [`TxOut`]s.
+#[derive(Clone, Debug)]
+struct TxOutWitnessesEncoder<'e> {
+    txouts: &'e [TxOut],
+    cur_enc: Option<TxOutWitnessEncoder<'e>>,
+}
+
+impl<'e> TxOutWitnessesEncoder<'e> {
+    fn new(txouts: &'e [TxOut]) -> Self {
+        Self { txouts, cur_enc: txouts.first().map(|txout| txout.witness.encoder()) }
+    }
+}
+
+impl Encoder for TxOutWitnessesEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        self.cur_enc.as_ref().map(Encoder::current_chunk).unwrap_or_default()
+    }
+
+    fn advance(&mut self) -> EncoderStatus {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return EncoderStatus::Finished;
+        };
+
+        loop {
+            if cur.advance().has_more() {
+                return EncoderStatus::HasMore;
+            }
+            // self.inputs guaranteed to be non-empty if cur_enc is non-None.
+            self.txouts = &self.txouts[1..];
+            if let Some(txout) = self.txouts.first() {
+                *cur = txout.witness.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return EncoderStatus::HasMore;
+                }
+            } else {
+                self.cur_enc = None;
+                return EncoderStatus::Finished;
+            }
+        }
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxOut`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxOutEncoder<'e>(Encoder4<
+        crate::confidential::AssetEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+        crate::confidential::NonceEncoder<'e>,
+        crate::script::ScriptEncoder<'e>,
+    >);
+}
+
+impl Encode for TxOut {
+    type Encoder<'e> = TxOutEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxOutEncoder::new(Encoder4::new(
+            self.asset.encoder(),
+            self.value.encoder(),
+            self.nonce.encoder(),
+            self.script_pubkey.encoder(),
+        ))
+    }
+}
+
+encoder_newtype! {
+    /// Encoder for the [`Transaction`] type.
+    pub struct TransactionEncoder<'e>(Encoder6<
+        ArrayEncoder<4>,
+        ArrayEncoder<1>,
+        PrefixedSliceEncoder<'e, TxIn>,
+        PrefixedSliceEncoder<'e, TxOut>,
+        LockTimeEncoder<'e>,
+        Option<Encoder2<
+            TxInWitnessesEncoder<'e>,
+            TxOutWitnessesEncoder<'e>,
+        >>
+    >);
+}
+
+impl Encode for Transaction {
+    type Encoder<'e> = TransactionEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let witness_flag = self.has_witness();
+        TransactionEncoder::new(Encoder6::new(
+            ArrayEncoder::without_length_prefix(self.version.to_le_bytes()),
+            ArrayEncoder::without_length_prefix([u8::from(witness_flag)]),
+            PrefixedSliceEncoder::new(&self.input),
+            PrefixedSliceEncoder::new(&self.output),
+            self.lock_time.encoder(),
+            witness_flag.then(|| {
+                Encoder2::new(
+                    TxInWitnessesEncoder::new(&self.input),
+                    TxOutWitnessesEncoder::new(&self.output),
+                )
+            }),
+        ))
+    }
+}
diff --git a/src/transaction.rs b/src/transaction/mod.rs
similarity index 84%
rename from src/transaction.rs
rename to src/transaction/mod.rs
index 4f086078..d74d9385 100644
--- a/src/transaction.rs
+++ b/src/transaction/mod.rs
@@ -15,31 +15,41 @@
 //! # Transactions
 //!
 
-use std::{io, fmt, str};
+mod decoders;
+mod encoders;
+mod pegin_witness;
+mod witness;
+
+use std::{io, fmt, str, cmp};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 
 use bitcoin::{self, VarInt};
-use crate::hashes::{Hash, sha256};
+use bitcoin::hashes::Hash as _;
+use crate::hashes::{sha256d, HashEngine as _};
 
-use crate::{confidential, ContractHash};
+use crate::confidential;
 use crate::encode::{self, Encodable, Decodable};
-use crate::issuance::AssetId;
+use crate::issuance::{AssetBlindingNonce, AssetEntropy, AssetId};
 use crate::opcodes;
 use crate::parse::impl_parse_str_through_int;
 use crate::script::Instruction;
-use crate::{PackedLockTime, Script, Txid, Wtxid};
-use secp256k1_zkp::{
-    RangeProof, SurjectionProof, Tweak, ZERO_TWEAK,
-};
+use crate::{LockTime, RangeProof, Script, SurjectionProof, Txid, Wtxid};
+
+pub use self::decoders::{AssetIssuanceDecoder, AssetIssuanceDecoderError, SequenceDecoder, SequenceDecoderError, TransactionDecoder, TransactionDecoderError, TxInDecoder, TxInDecoderError, TxInWitnessDecoder, TxInWitnessDecoderError, TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
+pub use self::encoders::{AssetIssuanceEncoder, SequenceEncoder, TransactionEncoder, TxInEncoder, TxInWitnessEncoder, TxOutEncoder, TxOutWitnessEncoder};
+pub use self::pegin_witness::{
+    PeginData, PeginDataDecoder, PeginDataEncoder,
+    PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder};
+pub use self::witness::{Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder};
 
 /// Description of an asset issuance in a transaction input
-#[derive(Copy, Clone, Debug, Default, Eq, Hash, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct AssetIssuance {
     /// Zero for a new asset issuance; otherwise a blinding factor for the input
-    pub asset_blinding_nonce: Tweak,
+    pub asset_blinding_nonce: AssetBlindingNonce,
     /// Freeform entropy field
-    pub asset_entropy: [u8; 32],
+    pub asset_entropy: AssetEntropy,
     /// Amount of asset to issue
     pub amount: confidential::Value,
     /// Amount of inflation keys to issue
@@ -47,15 +57,29 @@ pub struct AssetIssuance {
 }
 
 impl AssetIssuance {
+    /// Create a null issuance.
+    pub fn null() -> Self {
+        AssetIssuance {
+            asset_blinding_nonce: AssetBlindingNonce::NEW_ISSUANCE,
+            asset_entropy: AssetEntropy::NEW_ISSUANCE,
+            amount: confidential::Value::Null,
+            inflation_keys: confidential::Value::Null,
+        }
+    }
 
     /// Checks whether the [`AssetIssuance`] is null
     pub fn is_null(&self) -> bool {
         self.amount.is_null() && self.inflation_keys.is_null()
     }
 }
-serde_struct_impl!(AssetIssuance, asset_blinding_nonce, asset_entropy, amount, inflation_keys);
 impl_consensus_encoding!(AssetIssuance, asset_blinding_nonce, asset_entropy, amount, inflation_keys);
 
+impl Default for AssetIssuance {
+    fn default() -> Self {
+        Self::null()
+    }
+}
+
 /// A reference to a transaction output
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct OutPoint {
@@ -83,8 +107,8 @@ impl OutPoint {
     #[inline]
     pub fn null() -> OutPoint {
         OutPoint {
-            txid: Txid::all_zeros(),
-            vout: u32::max_value(),
+            txid: Txid::COINBASE_PREVOUT,
+            vout: u32::MAX,
         }
     }
 
@@ -135,7 +159,7 @@ impl ::std::str::FromStr for OutPoint {
         }
         let bitcoin_outpoint = bitcoin::OutPoint::from_str(s)?;
         Ok(OutPoint {
-            txid: Txid::from(bitcoin_outpoint.txid.as_hash()),
+            txid: Txid::from_byte_array(bitcoin_outpoint.txid.to_byte_array()),
             vout: bitcoin_outpoint.vout,
         })
     }
@@ -147,7 +171,7 @@ impl ::std::str::FromStr for OutPoint {
 /// - 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 transcation opts-in to [BIP-125] replace-by-fee.
+/// - Indicating whether a transaction opts-in to [BIP-125] replace-by-fee.
 ///
 /// Note that transactions spending an output with `OP_CHECKLOCKTIMEVERIFY`MUST NOT use
 /// `Sequence::MAX` for the corresponding input. [BIP-65]
@@ -156,8 +180,7 @@ impl ::std::str::FromStr for OutPoint {
 /// [BIP-68]: <https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki>
 /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Sequence(pub u32);
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -172,7 +195,7 @@ impl Sequence {
     /// The maximum allowable sequence number.
     ///
     /// This sequence number disables lock-time and replace-by-fee.
-    pub const MAX: Self = Sequence(0xFFFFFFFF);
+    pub const MAX: Self = Sequence(0xFFFF_FFFF);
     /// Zero value sequence.
     ///
     /// This sequence number enables replace-by-fee and lock-time.
@@ -182,7 +205,7 @@ impl Sequence {
     pub const ENABLE_LOCKTIME_NO_RBF: Self = Sequence::MIN_NO_RBF;
     /// The sequence number that enables replace-by-fee and absolute lock-time but
     /// disables relative lock-time.
-    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFFFFFD);
+    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFF_FFFD);
 
     /// The lowest sequence number that does not opt-in for replace-by-fee.
     ///
@@ -191,13 +214,13 @@ impl Sequence {
     /// (Explicit Signalling [BIP-125]).
     ///
     /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki]>
-    const MIN_NO_RBF: Self = Sequence(0xFFFFFFFE);
+    const MIN_NO_RBF: Self = Sequence(0xFFFF_FFFE);
     /// BIP-68 relative lock-time disable flag mask
-    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x80000000;
+    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x8000_0000;
     /// BIP-68 relative lock-time type flag mask
-    const LOCK_TYPE_MASK: u32 = 0x00400000;
+    const LOCK_TYPE_MASK: u32 = 0x0040_0000;
 
-    /// Retuns `true` if the sequence number indicates that the transaction is finalised.
+    /// Returns `true` if the sequence number indicates that the transaction is finalised.
     ///
     /// The sequence number being equal to 0xffffffff on all txin sequences indicates
     /// that the transaction is finalised.
@@ -223,13 +246,13 @@ impl Sequence {
     /// 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 & Sequence::LOCK_TYPE_MASK == 0
     }
 
-    /// Returns `true` if the sequene number encodes a time interval based relative lock-time.
+    /// 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 & Sequence::LOCK_TYPE_MASK > 0
     }
 
     /// Create a relative lock-time using block height.
@@ -266,7 +289,7 @@ impl Sequence {
     /// Will return an error if the input cannot be encoded in 16 bits.
     #[inline]
     pub fn from_seconds_ceil(seconds: u32) -> Result<Self, RelativeLockTimeError> {
-        if let Ok(interval) = u16::try_from((seconds + 511) / 512) {
+        if let Ok(interval) = u16::try_from(seconds.div_ceil(512)) {
             Ok(Sequence::from_512_second_intervals(interval))
         } else {
             Err(RelativeLockTimeError::IntegerOverflow(seconds))
@@ -333,8 +356,6 @@ impl fmt::Display for RelativeLockTimeError {
 
 impl_parse_str_through_int!(Sequence);
 
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for RelativeLockTimeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
@@ -343,111 +364,50 @@ impl std::error::Error for RelativeLockTimeError {
     }
 }
 
-
 /// Transaction input witness
-#[derive(Clone, Default, PartialEq, Eq, Debug, Hash)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxInWitness {
     /// Amount rangeproof
-    pub amount_rangeproof: Option<Box<RangeProof>>,
+    pub amount_rangeproof: RangeProof,
     /// Rangeproof for inflation keys
-    pub inflation_keys_rangeproof: Option<Box<RangeProof>>,
+    pub inflation_keys_rangeproof: RangeProof,
     /// Traditional script witness
-    pub script_witness: Vec<Vec<u8>>,
+    pub script_witness: Witness,
     /// Pegin witness, basically the same thing
-    pub pegin_witness: Vec<Vec<u8>>,
+    pub pegin_witness: PeginWitness,
 }
-serde_struct_impl!(TxInWitness, amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness);
 impl_consensus_encoding!(TxInWitness, amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness);
 
 impl TxInWitness {
+    /// Create an empty input witness.
+    pub fn empty() -> Self {
+        TxInWitness {
+            amount_rangeproof: RangeProof::EMPTY,
+            inflation_keys_rangeproof: RangeProof::EMPTY,
+            script_witness: Witness::new(),
+            pegin_witness: PeginWitness::EMPTY,
+        }
+    }
+
     /// Whether this witness is null
     pub fn is_empty(&self) -> bool {
-        self.amount_rangeproof.is_none() &&
-            self.inflation_keys_rangeproof.is_none() &&
+        self.amount_rangeproof.is_empty() &&
+            self.inflation_keys_rangeproof.is_empty() &&
             self.script_witness.is_empty() &&
             self.pegin_witness.is_empty()
     }
 }
 
-
-/// Parsed data from a transaction input's pegin witness
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-pub struct PeginData<'tx> {
-    /// Reference to the pegin output on the mainchain
-    pub outpoint: bitcoin::OutPoint,
-    /// The value, in satoshis, of the pegin
-    pub value: u64,
-    /// Asset type being pegged in
-    pub asset: AssetId,
-    /// Hash of genesis block of originating blockchain
-    pub genesis_hash: bitcoin::BlockHash,
-    /// The claim script that we should hash to tweak our address. Unparsed
-    /// to avoid unnecessary allocation and copying. Typical use is simply
-    /// to feed it raw into a hash function.
-    pub claim_script: &'tx [u8],
-    /// Mainchain transaction; not parsed to save time/memory since the
-    /// parsed transaction is typically not useful without auxillary
-    /// data (e.g. knowing how to compute pegin addresses for the
-    /// sidechain).
-    pub tx: &'tx [u8],
-    /// Merkle proof of transaction inclusion; also not parsed
-    pub merkle_proof: &'tx [u8],
-    /// The Bitcoin block that the pegin output appears in; scraped
-    /// from the transaction inclusion proof
-    pub referenced_block: bitcoin::BlockHash,
-}
-
-impl<'tx> PeginData<'tx> {
-    /// Construct the pegin data from a pegin witness.
-    /// Returns None if not a valid pegin witness.
-    pub fn from_pegin_witness(
-        pegin_witness: &'tx [Vec<u8>],
-        prevout: bitcoin::OutPoint,
-    ) -> Result<PeginData<'tx>, &'static str> {
-        if pegin_witness.len() != 6 {
-            return Err("size not 6");
-        }
-
-        Ok(PeginData {
-            outpoint: prevout,
-            value: bitcoin::consensus::deserialize(&pegin_witness[0]).map_err(|_| "invalid value")?,
-            asset: encode::deserialize(&pegin_witness[1]).map_err(|_| "invalid asset")?,
-            genesis_hash: bitcoin::consensus::deserialize(&pegin_witness[2])
-                .map_err(|_| "invalid genesis hash")?,
-            claim_script: &pegin_witness[3],
-            tx: &pegin_witness[4],
-            merkle_proof: &pegin_witness[5],
-            referenced_block: bitcoin::BlockHash::hash(&pegin_witness[5][0..80]),
-        })
-    }
-
-    /// Construct a pegin witness from the pegin data.
-    pub fn to_pegin_witness(&self) -> Vec<Vec<u8>> {
-        vec![
-            bitcoin::consensus::serialize(&self.value),
-            encode::serialize(&self.asset),
-            bitcoin::consensus::serialize(&self.genesis_hash),
-            self.claim_script.to_vec(),
-            self.tx.to_vec(),
-            self.merkle_proof.to_vec(),
-        ]
-    }
-
-    /// Parse the mainchain tx provided as pegin data.
-    pub fn parse_tx(&self) -> Result<bitcoin::Transaction, bitcoin::consensus::encode::Error> {
-        bitcoin::consensus::encode::deserialize(self.tx)
-    }
-
-    /// Parse the merkle inclusion proof provided as pegin data.
-    pub fn parse_merkle_proof(&self) -> Result<bitcoin::MerkleBlock, bitcoin::consensus::encode::Error> {
-        bitcoin::consensus::encode::deserialize(self.merkle_proof)
+impl Default for TxInWitness {
+    fn default() -> Self {
+        Self::empty()
     }
 }
 
 /// A transaction input, which defines old coins to be consumed
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxIn {
-    /// The reference to the previous output that is being used an an input
+    /// The reference to the previous output that is being used as an input
     pub previous_output: OutPoint,
     /// Flag indicating that `previous_outpoint` refers to something on the main chain
     pub is_pegin: bool,
@@ -470,18 +430,16 @@ pub struct TxIn {
 impl Default for TxIn {
     fn default() -> Self {
         Self {
-            previous_output: Default::default(), // same as in rust-bitcoin
+            previous_output: OutPoint::default(), // same as in rust-bitcoin
             is_pegin: false,
             script_sig: Script::new(),
             sequence: Sequence::MAX, // same as in rust-bitcoin
-            asset_issuance: Default::default(),
-            witness: Default::default()
+            asset_issuance: AssetIssuance::default(),
+            witness: TxInWitness::default()
         }
     }
 }
 
-serde_struct_impl!(TxIn, previous_output, is_pegin, script_sig, sequence, asset_issuance, witness);
-
 impl Encodable for TxIn {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
         let mut ret = 0;
@@ -513,7 +471,7 @@ impl Decodable for TxIn {
         let has_issuance;
         // Pegin/issuance flags are encoded into the high bits of `vout`, *except*
         // if vout is all 1's; this indicates a coinbase transaction
-        if outp.vout == 0xffffffff {
+        if outp.vout == 0xffff_ffff {
             is_pegin = false;
             has_issuance = false;
         } else {
@@ -523,6 +481,9 @@ impl Decodable for TxIn {
         }
         if has_issuance {
             issuance = AssetIssuance::consensus_decode(&mut d)?;
+            if issuance.is_null() {
+                return Err(encode::Error::ParseFailed("superfluous asset issuance"));
+            }
         } else {
             issuance = AssetIssuance::default();
         }
@@ -554,7 +515,9 @@ impl TxIn {
         if self.is_pegin {
             // here we have to cast the previous_output to a bitcoin one
             Some(bitcoin::OutPoint {
-                txid: bitcoin::Txid::from(self.previous_output.txid.as_hash()),
+                txid: bitcoin::Txid::from_byte_array(
+                    self.previous_output.txid.to_byte_array()
+                ),
                 vout: self.previous_output.vout,
             })
         } else {
@@ -565,10 +528,8 @@ impl TxIn {
     /// Extracts witness data from a pegin. Will return `None` if any data
     /// cannot be parsed. The combination of `is_pegin()` returning `true`
     /// and `pegin_data()` returning `None` indicates an invalid transaction.
-    pub fn pegin_data(&self) -> Option<PeginData> {
-        self.pegin_prevout().and_then(|p| {
-            PeginData::from_pegin_witness(&self.witness.pegin_witness, p).ok()
-        })
+    pub fn pegin_data(&self) -> Option<&PeginData> {
+        self.witness.pegin_witness.data()
     }
 
     /// Helper to determine whether an input has an asset issuance attached
@@ -578,19 +539,21 @@ impl TxIn {
 
     /// Obtain the outpoint flag corresponding to this input
     pub fn outpoint_flag(&self) -> u8 {
-        ((self.is_pegin as u8) << 6 ) | ((self.has_issuance() as u8) << 7)
+        (u8::from(self.is_pegin) << 6) | (u8::from(self.has_issuance()) << 7)
     }
 
     /// Compute the issuance asset ids from this [`TxIn`]. This function does not check
-    /// whether there is an issuance in this input. Returns (asset_id, token_id)
+    /// whether there is an issuance in this input. Returns (`asset_id`, `token_id`)
     pub fn issuance_ids(&self) -> (AssetId, AssetId) {
-        let entropy = if self.asset_issuance.asset_blinding_nonce == ZERO_TWEAK {
-            let contract_hash =
-                ContractHash::from_inner(self.asset_issuance.asset_entropy);
+        let entropy = if self.asset_issuance.asset_blinding_nonce.is_null() {
+            let contract_hash = self
+                .asset_issuance
+                .asset_entropy
+                .into_contract_hash();
             AssetId::generate_asset_entropy(self.previous_output, contract_hash)
         } else {
             // re-issuance
-            sha256::Midstate::from_inner(self.asset_issuance.asset_entropy)
+            self.asset_issuance.asset_entropy
         };
         let asset_id = AssetId::from_entropy(entropy);
         let token_id =
@@ -601,34 +564,47 @@ impl TxIn {
 }
 
 /// Transaction output witness
-#[derive(Clone, Default, PartialEq, Eq, Debug, Hash)]
+#[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxOutWitness {
     /// Surjection proof showing that the asset commitment is legitimate
     // We Box it because surjection proof internally is an array [u8; N] that
     // allocates on stack even when the surjection proof is empty
-    pub surjection_proof: Option<Box<SurjectionProof>>,
+    pub surjection_proof: SurjectionProof,
     /// Rangeproof showing that the value commitment is legitimate
     // We Box it because range proof internally is an array [u8; N] that
     // allocates on stack even when the range proof is empty
-    pub rangeproof: Option<Box<RangeProof>>,
+    pub rangeproof: RangeProof,
 }
-serde_struct_impl!(TxOutWitness, surjection_proof, rangeproof);
 impl_consensus_encoding!(TxOutWitness, surjection_proof, rangeproof);
 
 impl TxOutWitness {
+    /// Create an empty output witness.
+    pub fn empty() -> Self {
+        TxOutWitness {
+            surjection_proof: SurjectionProof::EMPTY,
+            rangeproof: RangeProof::EMPTY,
+        }
+    }
+
     /// Whether this witness is null
     pub fn is_empty(&self) -> bool {
-        self.surjection_proof.is_none() && self.rangeproof.is_none()
+        self.surjection_proof.is_empty() && self.rangeproof.is_empty()
     }
 
     /// The rangeproof len if is present, otherwise 0
     pub fn rangeproof_len(&self) -> usize {
-        self.rangeproof.as_ref().map(|prf| prf.len()).unwrap_or(0)
+        self.rangeproof.len()
     }
 
     /// The surjection proof len if is present, otherwise 0
     pub fn surjectionproof_len(&self) -> usize {
-        self.surjection_proof.as_ref().map(|prf| prf.len()).unwrap_or(0)
+        self.surjection_proof.len()
+    }
+}
+
+impl Default for TxOutWitness {
+    fn default() -> Self {
+        Self::empty()
     }
 }
 
@@ -642,13 +618,13 @@ pub struct PegoutData<'txo> {
     /// Genesis hash of the target blockchain
     pub genesis_hash: bitcoin::BlockHash,
     /// Scriptpubkey to create on the target blockchain
-    pub script_pubkey: bitcoin::Script,
+    pub script_pubkey: bitcoin::ScriptBuf,
     /// Remaining pegout data used by some forks of Elements
     pub extra_data: Vec<&'txo [u8]>,
 }
 
 /// Transaction output
-#[derive(Clone, Default, PartialEq, Eq, Debug, Hash)]
+#[derive(Clone, Default, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxOut {
     /// Committed asset
     pub asset: confidential::Asset,
@@ -663,7 +639,6 @@ pub struct TxOut {
     /// part of the txin.
     pub witness: TxOutWitness,
 }
-serde_struct_impl!(TxOut, asset, value, nonce, script_pubkey, witness);
 
 impl Encodable for TxOut {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
@@ -687,7 +662,6 @@ impl Decodable for TxOut {
 }
 
 impl TxOut {
-
     /// Create a new fee output.
     pub fn new_fee(amount: u64, asset: AssetId) -> TxOut {
         TxOut {
@@ -699,7 +673,7 @@ impl TxOut {
         }
     }
 
-    /// Whether this data represents nulldata (OP_RETURN followed by pushes,
+    /// Whether this data represents nulldata (`OP_RETURN` followed by pushes,
     /// not necessarily minimal)
     pub fn is_null_data(&self) -> bool {
         let mut iter = self.script_pubkey.instructions();
@@ -727,7 +701,7 @@ impl TxOut {
 
     /// If this output is a pegout, returns the destination genesis block,
     /// the destination script pubkey, and any additional data
-    pub fn pegout_data(&self) -> Option<PegoutData> {
+    pub fn pegout_data(&self) -> Option<PegoutData<'_>> {
         // Must be NULLDATA
         if !self.is_null_data() {
             return None;
@@ -741,11 +715,13 @@ impl TxOut {
         iter.next(); // Skip OP_RETURN
 
         // Parse destination chain's genesis block
-        let genesis_hash = bitcoin::BlockHash::from_slice(iter.next()?.ok()?.push_bytes()?).ok()?;
+        let genesis_hash = bitcoin::BlockHash::from_raw_hash(
+            bitcoin::hashes::Hash::from_slice(iter.next()?.ok()?.push_bytes()?).ok()?
+        );
 
         // Parse destination scriptpubkey
-        let script_pubkey = bitcoin::Script::from(iter.next()?.ok()?.push_bytes()?.to_owned());
-        if script_pubkey.len() == 0 {
+        let script_pubkey = bitcoin::ScriptBuf::from(iter.next()?.ok()?.push_bytes()?.to_owned());
+        if script_pubkey.is_empty() {
             return None;
         }
 
@@ -780,35 +756,13 @@ impl TxOut {
 
     /// Extracts the minimum value from the rangeproof, if there is one, or returns 0.
     pub fn minimum_value(&self) -> u64 {
-        let min_value = if self.script_pubkey.is_op_return() { 0 } else { 1 };
+        let min_value = u64::from(self.script_pubkey.is_op_return());
 
         match self.value {
             confidential::Value::Null => min_value,
             confidential::Value::Explicit(n) => n,
             confidential::Value::Confidential(..) => {
-                match &self.witness.rangeproof {
-                    None => min_value,
-                    Some(prf) => {
-                        // inefficient, consider implementing index on rangeproof
-                        let prf = prf.serialize();
-                        debug_assert!(prf.len() > 10);
-
-                        let has_nonzero_range = prf[0] & 64 == 64;
-                        let has_min = prf[0] & 32 == 32;
-
-                        if !has_min {
-                            min_value
-                        } else if has_nonzero_range {
-                            bitcoin::consensus::deserialize::<u64>(&prf[2..10])
-                                .expect("any 8 bytes is a u64")
-                                .swap_bytes()  // min-value is BE
-                        } else {
-                            bitcoin::consensus::deserialize::<u64>(&prf[1..9])
-                                .expect("any 8 bytes is a u64")
-                                .swap_bytes()  // min-value is BE
-                        }
-                    }
-                }
+                self.witness.rangeproof.minimim_value().unwrap_or(min_value)
             }
         }
     }
@@ -825,13 +779,12 @@ pub struct Transaction {
     /// Transaction version field (should always be 2)
     pub version: u32,
     /// Transaction locktime
-    pub lock_time: PackedLockTime,
+    pub lock_time: LockTime,
     /// Vector of inputs
     pub input: Vec<TxIn>,
     /// Vector of outputs
     pub output: Vec<TxOut>,
 }
-serde_struct_impl!(Transaction, version, lock_time, input, output);
 
 impl Transaction {
     /// Whether the transaction is a coinbase tx
@@ -869,13 +822,50 @@ impl Transaction {
         self.scaled_size(1)
     }
 
+    /// Returns the "virtual size" (vsize) of this transaction.
+    ///
+    /// Will be `ceil(weight / 4.0)`.
+    #[inline]
+    pub fn vsize(&self) -> usize {
+        let weight = self.weight();
+        weight.div_ceil(4)
+    }
+
+    /// Get the "discount weight" of this transaction; this is the weight minus the output witnesses and minus the
+    /// differences between asset and nonce commitments from their explicit values (weighted as part of the base transaction).
+    pub fn discount_weight(&self) -> usize {
+        let mut weight = self.scaled_size(4);
+
+        for out in &self.output {
+            let rp_len = out.witness.rangeproof_len();
+            let sp_len = out.witness.surjectionproof_len();
+            let witness_weight = VarInt(sp_len as u64).size() + sp_len + VarInt(rp_len as u64).size() + rp_len;
+            weight -= witness_weight.saturating_sub(2); // explicit transactions have 1 byte for each empty proof
+            if out.value.is_confidential() {
+                weight -= (33 - 9) * 4;
+            }
+            if out.nonce.is_confidential() {
+                weight -= (33 - 1) * 4;
+            }
+        }
+
+        weight
+    }
+
+    /// Returns the "discount virtual size" (discountvsize) of this transaction.
+    ///
+    /// Will be `ceil(discount weight / 4.0)`.
+    pub fn discount_vsize(&self) -> usize {
+        self.discount_weight().div_ceil(4)
+    }
+
     fn scaled_size(&self, scale_factor: usize) -> usize {
         let witness_flag = self.has_witness();
 
         let input_weight = self.input.iter().map(|input| {
             scale_factor * (
                 32 + 4 + 4 + // output + nSequence
-                VarInt(input.script_sig.len() as u64).len() as usize +
+                VarInt(input.script_sig.len() as u64).size() +
                 input.script_sig.len() + if input.has_issuance() {
                     64 +
                     input.asset_issuance.amount.encoded_length() +
@@ -884,25 +874,19 @@ impl Transaction {
                     0
                 }
             ) + if witness_flag {
-                let amt_prf_len = input.witness.amount_rangeproof.as_ref()
-                    .map(|x| x.len()).unwrap_or(0);
-                let keys_prf_len = input.witness.inflation_keys_rangeproof.as_ref()
-                    .map(|x| x.len()).unwrap_or(0);
+                let amt_prf_len = input.witness.amount_rangeproof.len();
+                let keys_prf_len = input.witness.inflation_keys_rangeproof.len();
 
-                VarInt(amt_prf_len as u64).len() as usize +
+                VarInt(amt_prf_len as u64).size() +
                 amt_prf_len +
-                VarInt(keys_prf_len as u64).len() as usize +
+                VarInt(keys_prf_len as u64).size() +
                 keys_prf_len +
-                VarInt(input.witness.script_witness.len() as u64).len() as usize +
+                VarInt(input.witness.script_witness.len() as u64).size() +
                 input.witness.script_witness.iter().map(|wit|
-                    VarInt(wit.len() as u64).len() as usize +
+                    VarInt(wit.len() as u64).size() +
                     wit.len()
                 ).sum::<usize>() +
-                VarInt(input.witness.pegin_witness.len() as u64).len() as usize +
-                input.witness.pegin_witness.iter().map(|wit|
-                    VarInt(wit.len() as u64).len() as usize +
-                    wit.len()
-                ).sum::<usize>()
+                input.witness.pegin_witness.encoded_size()
             } else {
                 0
             }
@@ -913,14 +897,14 @@ impl Transaction {
                 output.asset.encoded_length() +
                 output.value.encoded_length() +
                 output.nonce.encoded_length() +
-                VarInt(output.script_pubkey.len() as u64).len() as usize +
+                VarInt(output.script_pubkey.len() as u64).size() +
                 output.script_pubkey.len()
             ) + if witness_flag {
                 let range_prf_len = output.witness.rangeproof_len();
                 let surj_prf_len = output.witness.surjectionproof_len();
-                VarInt(surj_prf_len as u64).len() as usize +
+                VarInt(surj_prf_len as u64).size() +
                 surj_prf_len +
-                VarInt(range_prf_len as u64).len() as usize +
+                VarInt(range_prf_len as u64).size() +
                 range_prf_len
             } else {
                 0
@@ -930,28 +914,28 @@ impl Transaction {
         scale_factor * (
             4 + // version
             4 + // locktime
-            VarInt(self.input.len() as u64).len() as usize +
-            VarInt(self.output.len() as u64).len() as usize +
+            VarInt(self.input.len() as u64).size() +
+            VarInt(self.output.len() as u64).size() +
             1 // segwit flag byte (note this is *not* witness data in Elements)
         ) + input_weight + output_weight
     }
 
     /// The txid of the transaction.
     pub fn txid(&self) -> Txid {
-        let mut enc = Txid::engine();
+        let mut enc = sha256d::Hash::engine();
         self.version.consensus_encode(&mut enc).unwrap();
         0u8.consensus_encode(&mut enc).unwrap();
         self.input.consensus_encode(&mut enc).unwrap();
         self.output.consensus_encode(&mut enc).unwrap();
         self.lock_time.consensus_encode(&mut enc).unwrap();
-        Txid::from_engine(enc)
+        Txid(enc.finalize())
     }
 
     /// Get the witness txid of the transaction.
     pub fn wtxid(&self) -> Wtxid {
-        let mut enc = Txid::engine();
+        let mut enc = sha256d::Hash::engine();
         self.consensus_encode(&mut enc).unwrap();
-        Wtxid::from_engine(enc)
+        Wtxid(enc.finalize())
     }
 
     /// Get the total transaction fee in the given asset.
@@ -1021,7 +1005,7 @@ impl Decodable for Transaction {
         let wit_flag = u8::consensus_decode(&mut d)?;
         let mut input = Vec::<TxIn>::consensus_decode(&mut d)?;
         let mut output = Vec::<TxOut>::consensus_decode(&mut d)?;
-        let lock_time = PackedLockTime::consensus_decode(&mut d)?;
+        let lock_time = LockTime::consensus_decode(&mut d)?;
 
         match wit_flag {
             0 => Ok(Transaction {
@@ -1053,10 +1037,30 @@ impl Decodable for Transaction {
         }
     }
 }
+
+impl cmp::PartialOrd for Transaction {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl cmp::Ord for Transaction {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        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))
+    }
+}
+
 /// Hashtype of a transaction, encoded in the last byte of a signature
 /// Fixed values so they can be casted as integer types for encoding
 #[derive(PartialEq, Eq, Debug, Copy, Clone)]
-pub enum EcdsaSigHashType {
+pub enum EcdsaSighashType {
     /// 0x1: Sign all outputs
     All = 0x01,
     /// 0x2: Sign no outputs --- anyone can choose the destination
@@ -1074,64 +1078,64 @@ pub enum EcdsaSigHashType {
     SinglePlusAnyoneCanPay = 0x83,
 }
 
-serde_string_impl!(EcdsaSigHashType, "a EcdsaSigHashType data");
+serde_string_impl!(EcdsaSighashType, "a EcdsaSighashType data");
 
-impl fmt::Display for EcdsaSigHashType {
+impl fmt::Display for EcdsaSighashType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self {
-            EcdsaSigHashType::All => "SIGHASH_ALL",
-            EcdsaSigHashType::None => "SIGHASH_NONE",
-            EcdsaSigHashType::Single => "SIGHASH_SINGLE",
-            EcdsaSigHashType::AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
-            EcdsaSigHashType::NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
-            EcdsaSigHashType::SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
+            EcdsaSighashType::All => "SIGHASH_ALL",
+            EcdsaSighashType::None => "SIGHASH_NONE",
+            EcdsaSighashType::Single => "SIGHASH_SINGLE",
+            EcdsaSighashType::AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
+            EcdsaSighashType::NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
+            EcdsaSighashType::SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
         };
         f.write_str(s)
     }
 }
 
-impl str::FromStr for EcdsaSigHashType {
+impl str::FromStr for EcdsaSighashType {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.as_ref() {
-            "SIGHASH_ALL" => Ok(EcdsaSigHashType::All),
-            "SIGHASH_NONE" => Ok(EcdsaSigHashType::None),
-            "SIGHASH_SINGLE" => Ok(EcdsaSigHashType::Single),
-            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(EcdsaSigHashType::AllPlusAnyoneCanPay),
-            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(EcdsaSigHashType::NonePlusAnyoneCanPay),
-            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(EcdsaSigHashType::SinglePlusAnyoneCanPay),
+        match s {
+            "SIGHASH_ALL" => Ok(EcdsaSighashType::All),
+            "SIGHASH_NONE" => Ok(EcdsaSighashType::None),
+            "SIGHASH_SINGLE" => Ok(EcdsaSighashType::Single),
+            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(EcdsaSighashType::AllPlusAnyoneCanPay),
+            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(EcdsaSighashType::NonePlusAnyoneCanPay),
+            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(EcdsaSighashType::SinglePlusAnyoneCanPay),
             _ => Err("can't recognize SIGHASH string".to_string())
         }
     }
 }
 
-impl EcdsaSigHashType {
+impl EcdsaSighashType {
     /// Break 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) -> (EcdsaSighashType, bool) {
         match self {
-            EcdsaSigHashType::All => (EcdsaSigHashType::All, false),
-            EcdsaSigHashType::None => (EcdsaSigHashType::None, false),
-            EcdsaSigHashType::Single => (EcdsaSigHashType::Single, false),
-            EcdsaSigHashType::AllPlusAnyoneCanPay => (EcdsaSigHashType::All, true),
-            EcdsaSigHashType::NonePlusAnyoneCanPay => (EcdsaSigHashType::None, true),
-            EcdsaSigHashType::SinglePlusAnyoneCanPay => (EcdsaSigHashType::Single, true),
+            EcdsaSighashType::All => (EcdsaSighashType::All, false),
+            EcdsaSighashType::None => (EcdsaSighashType::None, false),
+            EcdsaSighashType::Single => (EcdsaSighashType::Single, false),
+            EcdsaSighashType::AllPlusAnyoneCanPay => (EcdsaSighashType::All, true),
+            EcdsaSighashType::NonePlusAnyoneCanPay => (EcdsaSighashType::None, true),
+            EcdsaSighashType::SinglePlusAnyoneCanPay => (EcdsaSighashType::Single, true),
         }
     }
 
     /// Reads a 4-byte uint32 as a sighash type
-    pub fn from_u32(n: u32) -> EcdsaSigHashType {
+    pub fn from_u32(n: u32) -> EcdsaSighashType {
         match n & 0x9f {
             // "real" sighashes
-            0x01 => EcdsaSigHashType::All,
-            0x02 => EcdsaSigHashType::None,
-            0x03 => EcdsaSigHashType::Single,
-            0x81 => EcdsaSigHashType::AllPlusAnyoneCanPay,
-            0x82 => EcdsaSigHashType::NonePlusAnyoneCanPay,
-            0x83 => EcdsaSigHashType::SinglePlusAnyoneCanPay,
+            0x01 => EcdsaSighashType::All,
+            0x02 => EcdsaSighashType::None,
+            0x03 => EcdsaSighashType::Single,
+            0x81 => EcdsaSighashType::AllPlusAnyoneCanPay,
+            0x82 => EcdsaSighashType::NonePlusAnyoneCanPay,
+            0x83 => EcdsaSighashType::SinglePlusAnyoneCanPay,
             // catchalls
-            x if x & 0x80 == 0x80 => EcdsaSigHashType::AllPlusAnyoneCanPay,
-            _ => EcdsaSigHashType::All,
+            x if x & 0x80 == 0x80 => EcdsaSighashType::AllPlusAnyoneCanPay,
+            _ => EcdsaSighashType::All,
         }
     }
 
@@ -1140,20 +1144,20 @@ impl EcdsaSigHashType {
         self as u32
     }
 
-    /// Creates a [`SigHashType`] from a raw `u32`.
+    /// Creates an [`EcdsaSighashType`] from a raw `u32`.
     ///
     /// # Errors
     ///
     /// If `n` is a non-standard sighash value.
-    pub fn from_standard(n: u32) -> Result<EcdsaSigHashType, NonStandardSighashType> {
+    pub fn from_standard(n: u32) -> Result<EcdsaSighashType, NonStandardSighashType> {
         match n {
             // Standard sighashes, see https://github.com/bitcoin/bitcoin/blob/b805dbb0b9c90dadef0424e5b3bf86ac308e103e/src/script/interpreter.cpp#L189-L198
-            0x01 => Ok(EcdsaSigHashType::All),
-            0x02 => Ok(EcdsaSigHashType::None),
-            0x03 => Ok(EcdsaSigHashType::Single),
-            0x81 => Ok(EcdsaSigHashType::AllPlusAnyoneCanPay),
-            0x82 => Ok(EcdsaSigHashType::NonePlusAnyoneCanPay),
-            0x83 => Ok(EcdsaSigHashType::SinglePlusAnyoneCanPay),
+            0x01 => Ok(EcdsaSighashType::All),
+            0x02 => Ok(EcdsaSighashType::None),
+            0x03 => Ok(EcdsaSighashType::Single),
+            0x81 => Ok(EcdsaSighashType::AllPlusAnyoneCanPay),
+            0x82 => Ok(EcdsaSighashType::NonePlusAnyoneCanPay),
+            0x83 => Ok(EcdsaSighashType::SinglePlusAnyoneCanPay),
             non_standard => Err(NonStandardSighashType(non_standard))
         }
     }
@@ -1191,12 +1195,10 @@ impl ::std::error::Error for SighashTypeParseError {}
 
 #[cfg(test)]
 mod tests {
-    use bitcoin;
-    use bitcoin::hashes::hex::FromHex;
+    use std::str::FromStr;
 
-    use crate::encode::serialize;
+    use crate::{encode::serialize, pset::PartiallySignedTransaction};
     use crate::confidential;
-    use secp256k1_zkp::{self, ZERO_TWEAK};
     use crate::script;
 
     use super::*;
@@ -1205,7 +1207,7 @@ mod tests {
     fn outpoint() {
         let txid = "d0a5c455ea7221dead9513596d2f97c09943bad81a386fe61a14a6cda060e422";
         let s = format!("{}:42", txid);
-        let expected = OutPoint::new(Txid::from_hex(&txid).unwrap(), 42);
+        let expected = OutPoint::new(Txid::from_str(txid).unwrap(), 42);
         let op = ::std::str::FromStr::from_str(&s).ok();
         assert_eq!(op, Some(expected));
         // roundtrip with elements prefix
@@ -1225,7 +1227,7 @@ mod tests {
 
         let tx = Transaction {
             version: 0,
-            lock_time: PackedLockTime::ZERO,
+            lock_time: LockTime::ZERO,
             input: vec![],
             output: vec![fee1, fee2],
         };
@@ -1262,12 +1264,12 @@ mod tests {
         assert_eq!(tx.output.len(), 2);
         assert_eq!(tx.size(), serialize(&tx).len());
         assert_eq!(tx.weight(), tx.size() * 4);
-        assert_eq!(tx.output[0].is_fee(), false);
-        assert_eq!(tx.output[1].is_fee(), true);
-        assert_eq!(tx.output[0].value, confidential::Value::Explicit(9999996700));
-        assert_eq!(tx.output[1].value, confidential::Value::Explicit(      3300));
-        assert_eq!(tx.output[0].minimum_value(), 9999996700);
-        assert_eq!(tx.output[1].minimum_value(),       3300);
+        assert!(!tx.output[0].is_fee());
+        assert!(tx.output[1].is_fee());
+        assert_eq!(tx.output[0].value, confidential::Value::Explicit(9_999_996_700));
+        assert_eq!(tx.output[1].value, confidential::Value::Explicit(3300));
+        assert_eq!(tx.output[0].minimum_value(), 9_999_996_700);
+        assert_eq!(tx.output[1].minimum_value(), 3300);
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
         assert_eq!(tx.fee_in(fee_asset), 3300);
         assert_eq!(tx.all_fees()[&fee_asset], 3300);
@@ -1473,21 +1475,21 @@ mod tests {
         assert_eq!(tx.size(), serialize(&tx).len());
         assert_eq!(tx.weight(), 7296);
         assert_eq!(tx.input.len(), 1);
-        assert_eq!(tx.input[0].is_coinbase(), false);
-        assert_eq!(tx.is_coinbase(), false);
+        assert!(!tx.input[0].is_coinbase());
+        assert!(!tx.is_coinbase());
 
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.output[0].is_fee(), false);
-        assert_eq!(tx.output[1].is_fee(), false);
-        assert_eq!(tx.output[2].is_fee(), true);
+        assert!(!tx.output[0].is_fee());
+        assert!(!tx.output[1].is_fee());
+        assert!(tx.output[2].is_fee());
 
         assert_eq!(tx.output[0].minimum_value(), 1);
         assert_eq!(tx.output[1].minimum_value(), 1);
         assert_eq!(tx.output[2].minimum_value(), 36480);
 
-        assert_eq!(tx.output[0].is_null_data(), false);
-        assert_eq!(tx.output[1].is_null_data(), false);
-        assert_eq!(tx.output[2].is_null_data(), false);
+        assert!(!tx.output[0].is_null_data());
+        assert!(!tx.output[1].is_null_data());
+        assert!(!tx.output[2].is_null_data());
 
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
         assert_eq!(tx.fee_in(fee_asset), 36480);
@@ -1515,16 +1517,16 @@ mod tests {
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.size(), serialize(&tx).len());
         assert_eq!(tx.weight(), 769);
-        assert_eq!(tx.input[0].is_coinbase(), true);
-        assert_eq!(!tx.input[0].is_pegin(), true);
+        assert!(tx.input[0].is_coinbase());
+        assert!(!tx.input[0].is_pegin());
         assert_eq!(tx.input[0].pegin_data(), None);
-        assert_eq!(tx.is_coinbase(), true);
+        assert!(tx.is_coinbase());
 
         assert_eq!(tx.output.len(), 2);
-        assert_eq!(tx.output[0].is_null_data(), true);
-        assert_eq!(tx.output[1].is_null_data(), true);
-        assert_eq!(tx.output[0].is_pegout(), false);
-        assert_eq!(tx.output[1].is_pegout(), false);
+        assert!(tx.output[0].is_null_data());
+        assert!(tx.output[1].is_null_data());
+        assert!(!tx.output[0].is_pegout());
+        assert!(!tx.output[1].is_pegout());
         assert_eq!(tx.output[0].pegout_data(), None);
         assert_eq!(tx.output[1].pegout_data(), None);
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
@@ -1567,29 +1569,23 @@ mod tests {
             "d1402017060761d77ee516f388134660d31ce9a72e546676303ac2fc3400656f"
         );
         assert_eq!(tx.input.len(), 1);
-        assert_eq!(tx.input[0].is_coinbase(), false);
-        assert_eq!(tx.input[0].is_pegin(), true);
+        assert!(!tx.input[0].is_coinbase());
+        assert!(tx.input[0].is_pegin());
         assert_eq!(tx.input[0].witness.pegin_witness.len(), 6);
         assert_eq!(
             tx.input[0].pegin_data(),
-            Some(super::PeginData {
-                outpoint: bitcoin::OutPoint {
-                    txid: bitcoin::Txid::from_hex(
-                        "c9d88eb5130365deed045eab11cfd3eea5ba32ad45fa2e156ae6ead5f1fce93f",
-                    ).unwrap(),
-                    vout: 0,
-                },
-                value: 100000000,
-                asset: tx.output[0].asset.explicit().unwrap(),
-                genesis_hash: bitcoin::BlockHash::from_hex(
+            Some(&super::PeginData {
+                value: 100_000_000,
+                asset_id: tx.output[0].asset.explicit().unwrap(),
+                genesis_hash: bitcoin::BlockHash::from_str(
                     "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
                 ).unwrap(),
-                claim_script: &[
+                claim_script: bitcoin::ScriptBuf::from(vec![
                     0x00, 0x14, 0x1a, 0xb7, 0xf5, 0x99, 0x5c, 0xf0,
                     0xdf, 0xcb, 0x90, 0xcb, 0xb0, 0x2b, 0x63, 0x39,
                     0x7e, 0x53, 0x26, 0xea, 0xe6, 0xfe,
-                ],
-                tx: &[
+                ]),
+                transaction: vec![
                     0x02, 0x00, 0x00, 0x00, 0x01, 0x13, 0x24, 0x4f,
                     0xa5, 0x9f, 0xcb, 0x40, 0x71, 0x24, 0x03, 0x8f,
                     0xf9, 0x12, 0x1e, 0xd5, 0x46, 0xf6, 0xdc, 0x21,
@@ -1615,7 +1611,7 @@ mod tests {
                     0xfc, 0x1f, 0xc8, 0xf1, 0xa4, 0x95, 0xaf, 0xfa,
                     0x88, 0xac, 0xf4, 0x01, 0x00, 0x00,
                 ],
-                merkle_proof: &[
+                merkle_proof: vec![
                     0x00, 0x00, 0x00, 0x20, 0xa0, 0x60, 0x08, 0x6a,
                     0xf9, 0x2a, 0xc3, 0x4d, 0xbb, 0xc8, 0xbd, 0x89,
                     0xbb, 0xbe, 0x03, 0xef, 0x7e, 0x00, 0x16, 0x93,
@@ -1640,21 +1636,21 @@ mod tests {
                     0x25, 0xf8, 0x55, 0x52, 0x97, 0x11, 0xed, 0x64,
                     0x50, 0xcc, 0x9b, 0x3c, 0x95, 0x01, 0x0b,
                 ],
-                referenced_block: bitcoin::BlockHash::from_hex(
+                referenced_block: bitcoin::BlockHash::from_str(
                     "297852caf43464d8f13a3847bd602184c21474cd06760dbf9fc5e87bade234f1"
                 ).unwrap(),
             })
         );
         assert_eq!(
             tx.input[0].witness.pegin_witness,
-            tx.input[0].pegin_data().unwrap().to_pegin_witness(),
+            PeginWitness::new(tx.input[0].pegin_data().unwrap().clone()),
         );
 
         assert_eq!(tx.output.len(), 2);
         assert!(!tx.output[0].is_null_data());
         assert!(!tx.output[1].is_null_data());
-        assert_eq!(tx.output[0].is_pegout(), false);
-        assert_eq!(tx.output[1].is_pegout(), false);
+        assert!(!tx.output[0].is_pegout());
+        assert!(!tx.output[1].is_pegout());
         assert_eq!(tx.output[0].pegout_data(), None);
         assert_eq!(tx.output[1].pegout_data(), None);
         let fee_asset = "630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8".parse().unwrap();
@@ -1685,8 +1681,8 @@ mod tests {
         );
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.output.len(), 1);
-        assert_eq!(tx.output[0].is_null_data(), true);
-        assert_eq!(tx.output[0].is_pegout(), true);
+        assert!(tx.output[0].is_null_data());
+        assert!(tx.output[0].is_pegout());
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
         assert_eq!(tx.fee_in(fee_asset), 0);
         assert!(tx.all_fees().is_empty());
@@ -1694,11 +1690,11 @@ mod tests {
             tx.output[0].pegout_data(),
             Some(super::PegoutData {
                 asset: tx.output[0].asset,
-                value: 99993900,
-                genesis_hash: bitcoin::BlockHash::from_hex(
+                value: 99_993_900,
+                genesis_hash: bitcoin::BlockHash::from_str(
                     "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
                 ).unwrap(),
-                script_pubkey: bitcoin::Script::from_hex(
+                script_pubkey: bitcoin::ScriptBuf::from_hex(
                     "76a914bedb324be05d1a1254afeb3e7ef40fea0368bc1e88ac"
                 ).unwrap(),
                 extra_data: vec![
@@ -1724,7 +1720,7 @@ mod tests {
             })
         );
 
-        let expected_asset_id = AssetId::from_hex("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8").unwrap();
+        let expected_asset_id = AssetId::from_str("630ed6f9b176af03c0cd3f8aa430f9e7b4d988cf2d0b2f204322488f03b00bf8").unwrap();
         if let confidential::Asset::Explicit(asset_id) = tx.output[0].asset {
             assert_eq!(expected_asset_id, asset_id);
         } else {
@@ -2040,15 +2036,15 @@ mod tests {
         );
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.input[0].has_issuance(), true);
+        assert!(tx.input[0].has_issuance());
         let fee_asset = "b2e15d0d7a0c94e4e2ce0fe6e8691b9e451377f6e46e8045a86f7c4b5d4f0f23".parse().unwrap();
         assert_eq!(tx.fee_in(fee_asset), 56400);
         assert_eq!(tx.all_fees()[&fee_asset], 56400);
         assert_eq!(
             tx.input[0].asset_issuance,
             AssetIssuance {
-                asset_blinding_nonce: ZERO_TWEAK,
-                asset_entropy: [0; 32],
+                asset_blinding_nonce: AssetBlindingNonce::NEW_ISSUANCE,
+                asset_entropy: AssetEntropy::NEW_ISSUANCE,
                 amount: confidential::Value::from_commitment(
                     &[  0x09, 0x81, 0x65, 0x4e, 0xb5, 0xcc, 0xd9, 0x92,
                         0x7b, 0x8b, 0xea, 0x94, 0x99, 0x7d, 0xce, 0x4a,
@@ -2292,4 +2288,194 @@ mod tests {
         ");
         assert!(tx.input[0].previous_output.is_null());
     }
+
+    #[test]
+    fn superfluous_asset_issuance() {
+        let tx = hex::decode_to_vec("1ae80068000109fee1000000000000000000000000000000000000000000000000000000000000005acf37f60000c7280028a7000000006e000000010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010115190000b9bfb80000000100000000d8d8d8d8d8d8d8d8d8d8d8d8d8d80000000000b8bfb8").unwrap();
+        assert!(matches!(
+            Transaction::consensus_decode(&tx[..]),
+            Err(encode::Error::ParseFailed("superfluous asset issuance")),
+        ));
+    }
+
+    #[test]
+    fn malformed_pegin() {
+        let wit = hex::decode_to_vec("\
+            0000000608202020202020202020202020202020202020202020202020202020\
+            2020202020202020202020202020202020202020202020202020202020202020\
+            2020202020202020202020202020202020202020202020202020202020200000\
+            00000000000000000000000000000002000400000000\
+        ").unwrap();
+        assert!(TxInWitness::consensus_decode(&wit[..]).is_err());
+    }
+
+    #[test]
+    fn discount_vsize() {
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_pegin.hex"));
+        assert_eq!(tx.input.len(), 1);
+        assert!(tx.input[0].is_pegin());
+        assert_eq!(tx.output.len(), 2);
+        assert_eq!(tx.weight(), 2403);
+        assert_eq!(tx.vsize(), 601);
+        assert_eq!(tx.discount_weight(), 2403);
+        assert_eq!(tx.discount_vsize(), 601);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_tx.hex"));
+        assert_eq!(tx.input.len(), 1);
+        assert_eq!(tx.output.len(), 2);
+        assert_eq!(tx.weight(), 5330);
+        assert_eq!(tx.vsize(), 1333);
+        assert_eq!(tx.discount_weight(), 863);
+        assert_eq!(tx.discount_vsize(), 216);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in3out_tx.hex"));
+        assert_eq!(tx.input.len(), 1);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 10107);
+        assert_eq!(tx.vsize(), 2527);
+        assert_eq!(tx.discount_weight(), 1173);
+        assert_eq!(tx.discount_vsize(), 294);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in3out_exp.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 1302);
+        assert_eq!(tx.vsize(), 326);
+        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_vsize(), 326);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in3out_tx.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 10300);
+        assert_eq!(tx.vsize(), 2575);
+        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_vsize(), 326);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in3out_tx.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 10300);
+        assert_eq!(tx.vsize(), 2575);
+        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_vsize(), 326);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in3out_tx2.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 10536);
+        assert_eq!(tx.vsize(), 2634);
+        assert_eq!(tx.discount_weight(), 1538);
+        assert_eq!(tx.discount_vsize(), 385);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/3in3out_tx.hex"));
+        assert_eq!(tx.input.len(), 3);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 10922);
+        assert_eq!(tx.vsize(), 2731);
+        assert_eq!(tx.discount_weight(), 1860);
+        assert_eq!(tx.discount_vsize(), 465);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/4in3out_tx.hex"));
+        assert_eq!(tx.input.len(), 4);
+        assert_eq!(tx.output.len(), 3);
+        assert_eq!(tx.weight(), 11192);
+        assert_eq!(tx.vsize(), 2798);
+        assert_eq!(tx.discount_weight(), 2130);
+        assert_eq!(tx.discount_vsize(), 533);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in4out_tx.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 4);
+        assert_eq!(tx.weight(), 15261);
+        assert_eq!(tx.vsize(), 3816);
+        assert_eq!(tx.discount_weight(), 1764);
+        assert_eq!(tx.discount_vsize(), 441);
+
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/2in5out_tx.hex"));
+        assert_eq!(tx.input.len(), 2);
+        assert_eq!(tx.output.len(), 5);
+        assert_eq!(tx.weight(), 20030);
+        assert_eq!(tx.vsize(), 5008);
+        assert_eq!(tx.discount_weight(), 2034);
+        assert_eq!(tx.discount_vsize(), 509);
+    }
+
+    #[test]
+    fn elip203() {
+        // Check that rust-elements can deserialize tests vector from ELIP203
+        // from
+        // https://github.com/ElementsProject/ELIPs/blob/main/elip-0203.mediawiki
+        let tx3: Transaction = hex_deserialize!(include_str!("../../tests/data/elip203_3.hex"));
+        let tx4: Transaction = hex_deserialize!(include_str!("../../tests/data/elip203_4.hex"));
+        let max_money = 2_100_000_000_000_000;
+        assert!(tx3.input[0].asset_issuance.amount.explicit().unwrap() > max_money);
+        assert!(tx4.input[0].asset_issuance.inflation_keys.explicit().unwrap() > max_money);
+    }
+
+    #[test]
+    fn pset_pegin_witnesses_encoding_round_trip() {
+        use crate::encode::{serialize, deserialize};
+
+        // Start with a transaction that has a pegin.
+        let base_tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_pegin.hex"));
+
+        // Test case (a): input witnesses but no output witnesses
+        let mut tx_input_only = base_tx.clone();
+        for output in &mut tx_input_only.output {
+            output.witness = TxOutWitness::empty();
+        }
+
+        // Test case (b): output witnesses but no input witnesses
+        let mut tx_output_only = base_tx.clone();
+        for input in &mut tx_output_only.input {
+            input.witness = TxInWitness::empty();
+        }
+
+        // Test case (c): no witnesses at all
+        let mut tx_no_witnesses = base_tx.clone();
+        for input in &mut tx_no_witnesses.input {
+            input.witness = TxInWitness::empty();
+        }
+        for output in &mut tx_no_witnesses.output {
+            output.witness = TxOutWitness::empty();
+        }
+
+        // Test all cases: serialize then deserialize and verify they match
+        let test_cases = vec![
+            ("input_witnesses_only", tx_input_only),
+            ("output_witnesses_only", tx_output_only),
+            ("no_witnesses", tx_no_witnesses),
+            ("both_witnesses", base_tx),
+        ];
+
+        for (name, original_tx) in test_cases {
+            let psbt = PartiallySignedTransaction::from_tx(original_tx.clone());
+            let psbt_tx = psbt.extract_tx().unwrap();
+            assert_eq!(original_tx, psbt_tx);
+
+            // Serialize the transaction
+            let serialized = serialize(&original_tx);
+            let serialized_psbt = serialize(&psbt_tx);
+
+            // Deserialize it back
+            let deserialized_tx: Transaction = deserialize(&serialized)
+                .unwrap_or_else(|e| panic!("Failed to deserialize {} transaction: {}", name, e));
+            let deserialized_psbt_tx: Transaction = deserialize(&serialized_psbt)
+                .unwrap_or_else(|e| panic!("Failed to deserialize {} transaction: {}", name, e));
+
+            // Verify they match exactly
+            assert_eq!(original_tx, deserialized_tx,
+                "Roundtrip failed for {} transaction", name);
+            assert_eq!(original_tx, deserialized_psbt_tx,
+                "Roundtrip failed for {} transaction", name);
+
+            // Verify reserialization is consistent
+            let reserialized = serialize(&deserialized_tx);
+            assert_eq!(serialized.len(), reserialized.len(),
+                "Serialized length changed for {} transaction", name);
+            assert_eq!(serialized, reserialized,
+                "Serialized bytes changed for {} transaction", name);
+        }
+    }
 }
diff --git a/src/transaction/pegin_witness.rs b/src/transaction/pegin_witness.rs
new file mode 100644
index 00000000..9b2326fd
--- /dev/null
+++ b/src/transaction/pegin_witness.rs
@@ -0,0 +1,560 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Pegin Witnesses
+
+use core::fmt;
+use std::io;
+
+// lol should these be accessible from a more convenient path?
+use bitcoin::block::BlockHashDecoder as GenesisHashDecoder;
+use bitcoin::block::{
+    BlockHashDecoderError as GenesisHashDecoderError, BlockHashEncoder as GenesisHashEncoder,
+};
+use bitcoin::hashes::Hash as _;
+use hashes::encoding::UnexpectedEofError;
+
+use crate::{encode, encoding, AssetId};
+
+const TOTAL_PEGIN_LENGTH: usize = 6;
+
+/// A pegin witness, which must be either a stack of 6 well-formed pieces of pegin data, or an empty witness stack.
+#[derive(Default, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
+pub struct PeginWitness {
+    inner: Option<PeginData>,
+}
+
+impl PeginWitness {
+    /// An empty pegin witness.
+    pub const EMPTY: Self = Self { inner: None };
+
+    /// A pegin witness containing the given data.
+    pub fn new(data: PeginData) -> Self { Self { inner: Some(data) } }
+
+    /// Accessor for the pegin witness data.
+    pub fn data(&self) -> Option<&PeginData> { self.inner.as_ref() }
+
+    /// Accessor for the pegin witness data.
+    pub fn into_data(self) -> Option<PeginData> { self.inner }
+
+    /// Whether this pegin witness is empty (no pegin).
+    pub fn is_empty(&self) -> bool { self.inner.is_none() }
+
+    /// The number of witness elements in the [`PeginWitness`].
+    pub fn len(&self) -> usize {
+        if self.inner.is_some() {
+            TOTAL_PEGIN_LENGTH
+        } else {
+            0
+        }
+    }
+
+    /// The number of bytes used to encode the [`PeginWitness`].
+    pub fn encoded_size(&self) -> usize {
+        use encoding::{Encode as _, ExactSizeEncoder as _};
+        match self.inner {
+            Some(ref data) => data.encoder().len(),
+            None => 1,
+        }
+    }
+}
+
+/// Encoder for the [`PeginWitness`] type.
+#[derive(Clone, Debug)]
+pub struct PeginWitnessEncoder<'e>(PeginWitnessEncoderInner<'e>);
+
+#[derive(Clone, Debug)]
+#[allow(clippy::large_enum_variant)]
+enum PeginWitnessEncoderInner<'e> {
+    Pegin(PeginDataEncoder<'e>),
+    Empty(encoding::CompactSizeEncoder),
+}
+
+impl encoding::Encoder for PeginWitnessEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref enc) => enc.current_chunk(),
+            Inner::Empty(ref enc) => enc.current_chunk(),
+        }
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref mut enc) => enc.advance(),
+            Inner::Empty(ref mut enc) => enc.advance(),
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for PeginWitnessEncoder<'_> {
+    fn len(&self) -> usize {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref enc) => enc.len(),
+            Inner::Empty(ref enc) => enc.len(),
+        }
+    }
+}
+
+impl encoding::Encode for PeginWitness {
+    type Encoder<'e> = PeginWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        match self.inner {
+            Some(ref data) => PeginWitnessEncoder(PeginWitnessEncoderInner::Pegin(data.encoder())),
+            None => PeginWitnessEncoder(PeginWitnessEncoderInner::Empty(
+                encoding::CompactSizeEncoder::new(0),
+            )),
+        }
+    }
+}
+
+/// Decoder for the [`PeginWitness`] type.
+#[derive(Default)]
+pub struct PeginWitnessDecoder(PeginWitnessDecoderInner);
+
+#[derive(Default)]
+#[allow(clippy::large_enum_variant)]
+enum PeginWitnessDecoderInner {
+    #[default]
+    Undetermined,
+    Empty,
+    Pegin(PeginDataDecoder),
+}
+
+impl encoding::Decoder for PeginWitnessDecoder {
+    type Output = PeginWitness;
+    type Error = PeginWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        use PeginWitnessDecoderInner as Inner;
+        loop {
+            match self.0 {
+                Inner::Undetermined => {
+                    match bytes.first().copied().map(usize::from) {
+                        None => return Ok(encoding::DecoderStatus::NeedsMore),
+                        Some(0) => {
+                            *bytes = &bytes[1..];
+                            self.0 = Inner::Empty;
+                        }
+                        Some(TOTAL_PEGIN_LENGTH) => {
+                            // don't advance `bytes`; the PeginDataDecoder will
+                            self.0 = Inner::Pegin(PeginDataDecoder::default());
+                        }
+                        Some(x) => {
+                            return Err(PeginWitnessDecoderError {
+                                field: "pegin witness",
+                                inner: PeginDataDecoderErrorInner::Length(
+                                    ExactLengthDecoderError::IncorrectLength {
+                                        expected: TOTAL_PEGIN_LENGTH,
+                                        got: x,
+                                    },
+                                ),
+                            });
+                        }
+                    }
+                }
+                Inner::Empty => return Ok(encoding::DecoderStatus::Ready),
+                Inner::Pegin(ref mut decoder) => return decoder.push_bytes(bytes),
+            }
+        }
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use PeginWitnessDecoderInner as Inner;
+        match self.0 {
+            Inner::Undetermined => Err(PeginWitnessDecoderError {
+                field: "pegin witness",
+                inner: PeginDataDecoderErrorInner::InsufficientLength { minimum: 1, got: 0 },
+            }),
+            Inner::Empty => Ok(PeginWitness { inner: None }),
+            Inner::Pegin(decoder) => decoder.end().map(|inner| PeginWitness { inner: Some(inner) }),
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        use PeginWitnessDecoderInner as Inner;
+        match self.0 {
+            Inner::Undetermined => 1,
+            Inner::Empty => 0,
+            Inner::Pegin(ref decoder) => decoder.read_limit(),
+        }
+    }
+}
+
+impl encoding::Decode for PeginWitness {
+    type Decoder = PeginWitnessDecoder;
+}
+
+/// Parsed data from a transaction input's pegin witness
+#[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
+pub struct PeginData {
+    /// The value, in satoshis, of the pegin
+    pub value: u64,
+    /// Asset type being pegged in
+    pub asset_id: AssetId,
+    /// Hash of genesis block of originating blockchain
+    pub genesis_hash: bitcoin::BlockHash,
+    /// The claim script that we should hash to tweak our address.
+    pub claim_script: bitcoin::ScriptBuf,
+    /// Mainchain transaction; not parsed to save time/memory since the
+    /// parsed transaction is typically not useful without auxiliary
+    /// data (e.g. knowing how to compute pegin addresses for the
+    /// sidechain).
+    pub transaction: Vec<u8>,
+    /// Merkle proof of transaction inclusion. Also not parsed.
+    pub merkle_proof: Vec<u8>,
+    /// The Bitcoin block that the pegin output appears in; scraped
+    /// from the transaction inclusion proof
+    pub referenced_block: bitcoin::BlockHash,
+}
+
+impl PeginData {
+    /// Parse the mainchain tx provided as pegin data.
+    pub fn parse_tx(&self) -> Result<bitcoin::Transaction, bitcoin::consensus::encode::Error> {
+        bitcoin::consensus::encode::deserialize(&self.transaction)
+    }
+
+    /// Parse the merkle inclusion proof provided as pegin data.
+    pub fn parse_merkle_proof(
+        &self,
+    ) -> Result<bitcoin::MerkleBlock, bitcoin::consensus::encode::Error> {
+        bitcoin::consensus::encode::deserialize(&self.merkle_proof)
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// An encoder for the [`PeginWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct PeginDataEncoder<'e>(
+        encoding::Encoder3<
+            // top-level compactsize
+            encoding::CompactSizeEncoder,
+            encoding::Encoder6<
+                // value
+                encoding::CompactSizeEncoder,
+                encoding::ArrayEncoder<8>,
+                // asset ID
+                encoding::CompactSizeEncoder,
+                encoding::ArrayRefEncoder<'e, 32>,
+                // genesis hash
+                encoding::CompactSizeEncoder,
+                GenesisHashEncoder<'e>,
+            >,
+            encoding::Encoder3<
+                // claim script
+                bitcoin::blockdata::script::ScriptEncoder<'e>,
+                // transaction
+                encoding::PrefixedBytesEncoder<'e>,
+                // merkle proof
+                encoding::PrefixedBytesEncoder<'e>,
+
+            >,
+        >
+    );
+}
+
+impl encoding::Encode for PeginData {
+    type Encoder<'e> = PeginDataEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        PeginDataEncoder::new(encoding::Encoder3::new(
+            encoding::CompactSizeEncoder::new(TOTAL_PEGIN_LENGTH),
+            encoding::Encoder6::new(
+                encoding::CompactSizeEncoder::new(8),
+                encoding::ArrayEncoder::without_length_prefix(self.value.to_le_bytes()),
+                encoding::CompactSizeEncoder::new(32),
+                encoding::ArrayRefEncoder::without_length_prefix(self.asset_id.as_byte_array()),
+                encoding::CompactSizeEncoder::new(32),
+                self.genesis_hash.encoder(),
+            ),
+            encoding::Encoder3::new(
+                self.claim_script.encoder(),
+                encoding::PrefixedBytesEncoder::new(&self.transaction),
+                encoding::PrefixedBytesEncoder::new(&self.merkle_proof),
+            ),
+        ))
+    }
+}
+
+struct ExactLengthDecoder {
+    target: usize,
+    inner: encoding::CompactSizeDecoder,
+}
+
+impl ExactLengthDecoder {
+    fn new(target: usize) -> Self { Self { target, inner: encoding::CompactSizeDecoder::new() } }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum ExactLengthDecoderError {
+    IncorrectLength { expected: usize, got: usize },
+    InvalidCompactSize(encoding::CompactSizeDecoderError),
+}
+
+impl fmt::Display for ExactLengthDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            Self::IncorrectLength { expected, got } => {
+                write!(f, "expected length {expected} but got {got}")
+            }
+            Self::InvalidCompactSize(_) => f.write_str("failed to decode compact size"),
+        }
+    }
+}
+
+impl std::error::Error for ExactLengthDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::IncorrectLength { .. } => None,
+            Self::InvalidCompactSize(ref error) => Some(error),
+        }
+    }
+}
+
+impl encoding::Decoder for ExactLengthDecoder {
+    type Output = usize;
+    type Error = ExactLengthDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(ExactLengthDecoderError::InvalidCompactSize)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let expected = self.target;
+        let got = self.inner.end().map_err(ExactLengthDecoderError::InvalidCompactSize)?;
+
+        if got == self.target {
+            Ok(got)
+        } else {
+            Err(ExactLengthDecoderError::IncorrectLength { expected, got })
+        }
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// A decoder for the [`PeginData`] type.
+#[allow(clippy::type_complexity)]
+pub struct PeginDataDecoder {
+    inner: encoding::Decoder3<
+        // top-level compactsize
+        ExactLengthDecoder,
+        encoding::Decoder6<
+            // value
+            ExactLengthDecoder,
+            encoding::ArrayDecoder<8>,
+            // asset ID
+            ExactLengthDecoder,
+            crate::AssetIdDecoder,
+            // genesis hash
+            ExactLengthDecoder,
+            GenesisHashDecoder,
+        >,
+        encoding::Decoder3<
+            // claim script
+            bitcoin::blockdata::script::ScriptBufDecoder,
+            // transaction
+            encoding::ByteVecDecoder,
+            // merkle proof
+            encoding::ByteVecDecoder,
+        >,
+    >,
+}
+
+impl Default for PeginDataDecoder {
+    fn default() -> Self {
+        Self {
+            inner: encoding::Decoder3::new(
+                ExactLengthDecoder::new(TOTAL_PEGIN_LENGTH),
+                encoding::Decoder6::new(
+                    ExactLengthDecoder::new(8),
+                    encoding::ArrayDecoder::new(),
+                    ExactLengthDecoder::new(32),
+                    crate::AssetIdDecoder::default(),
+                    ExactLengthDecoder::new(32),
+                    GenesisHashDecoder::new(),
+                ),
+                encoding::Decoder3::new(
+                    bitcoin::blockdata::script::ScriptBufDecoder::new(),
+                    encoding::ByteVecDecoder::new(),
+                    encoding::ByteVecDecoder::new(),
+                ),
+            ),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum PeginDataDecoderErrorInner {
+    AssetId(crate::AssetIdDecoderError),
+    ClaimScript(bitcoin::blockdata::script::ScriptBufDecoderError),
+    GenesisHash(GenesisHashDecoderError),
+    Length(ExactLengthDecoderError),
+    InsufficientLength { minimum: usize, got: usize },
+    Eof(encoding::UnexpectedEofError),
+    ByteVec(encoding::ByteVecDecoderError),
+}
+
+/// Error type for the decoding of [`PeginData`] or [`PeginWitness`].
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct PeginWitnessDecoderError {
+    field: &'static str,
+    inner: PeginDataDecoderErrorInner,
+}
+
+impl fmt::Display for PeginWitnessDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.field == "pegin witness" {
+            f.write_str("error decoding pegin witness")?;
+        } else {
+            write!(f, "error decoding pegin witness field {}", self.field)?;
+        }
+        if let PeginDataDecoderErrorInner::InsufficientLength { minimum, got } = self.inner {
+            write!(f, ": needed at least {minimum} bytes, got {got}")?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for PeginWitnessDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use PeginDataDecoderErrorInner as Inner;
+        match self.inner {
+            Inner::AssetId(ref e) => Some(e),
+            Inner::ClaimScript(ref e) => Some(e),
+            Inner::GenesisHash(ref e) => Some(e),
+            Inner::Length(ref e) => Some(e),
+            Inner::InsufficientLength { .. } => None,
+            Inner::Eof(ref e) => Some(e),
+            Inner::ByteVec(ref e) => Some(e),
+        }
+    }
+}
+
+impl PeginWitnessDecoderError {
+    /// Private error conversion function.
+    #[allow(clippy::type_complexity)]
+    fn from(
+        inner: encoding::Decoder3Error<
+            ExactLengthDecoderError,
+            encoding::Decoder6Error<
+                ExactLengthDecoderError,
+                UnexpectedEofError,
+                ExactLengthDecoderError,
+                crate::AssetIdDecoderError,
+                ExactLengthDecoderError,
+                GenesisHashDecoderError,
+            >,
+            encoding::Decoder3Error<
+                bitcoin::blockdata::script::ScriptBufDecoderError,
+                encoding::ByteVecDecoderError,
+                encoding::ByteVecDecoderError,
+            >,
+        >,
+    ) -> Self {
+        use encoding::{Decoder3Error as Dec3Err, Decoder6Error as Dec6Err};
+
+        match inner {
+            Dec3Err::First(error) =>
+                Self { field: "pegin witness", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::First(error)) =>
+                Self { field: "value", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Second(error)) =>
+                Self { field: "value", inner: PeginDataDecoderErrorInner::Eof(error) },
+            Dec3Err::Second(Dec6Err::Third(error)) =>
+                Self { field: "asset ID", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Fourth(error)) =>
+                Self { field: "asset ID", inner: PeginDataDecoderErrorInner::AssetId(error) },
+            Dec3Err::Second(Dec6Err::Fifth(error)) =>
+                Self { field: "genesis hash", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Sixth(error)) => Self {
+                field: "genesis hash",
+                inner: PeginDataDecoderErrorInner::GenesisHash(error),
+            },
+            Dec3Err::Third(Dec3Err::First(error)) => Self {
+                field: "claim script",
+                inner: PeginDataDecoderErrorInner::ClaimScript(error),
+            },
+            Dec3Err::Third(Dec3Err::Second(error)) =>
+                Self { field: "transaction", inner: PeginDataDecoderErrorInner::ByteVec(error) },
+            Dec3Err::Third(Dec3Err::Third(error)) =>
+                Self { field: "merkle proof", inner: PeginDataDecoderErrorInner::ByteVec(error) },
+        }
+    }
+}
+
+impl encoding::Decoder for PeginDataDecoder {
+    type Output = PeginData;
+    type Error = PeginWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(PeginWitnessDecoderError::from)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use internals::slice::SliceExt;
+
+        let (
+            _,
+            (_, value, _, asset_id, _, genesis_hash),
+            (claim_script, transaction, merkle_proof),
+        ) = self.inner.end().map_err(PeginWitnessDecoderError::from)?;
+
+        let Some((block_header, _)) = SliceExt::split_first_chunk::<80>(merkle_proof.as_slice())
+        else {
+            return Err(PeginWitnessDecoderError {
+                field: "merkle proof",
+                inner: PeginDataDecoderErrorInner::InsufficientLength {
+                    minimum: 80,
+                    got: merkle_proof.len(),
+                },
+            });
+        };
+        let referenced_block = bitcoin::BlockHash::hash(block_header);
+
+        Ok(PeginData {
+            value: u64::from_le_bytes(value),
+            asset_id,
+            genesis_hash,
+            claim_script,
+            transaction,
+            merkle_proof,
+            referenced_block,
+        })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+impl encoding::Decode for PeginData {
+    type Decoder = PeginDataDecoder;
+}
+
+impl encode::Encodable for PeginData {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        let mut counter = encode::ByteCounter::new(e);
+        crate::encoding::encode_to_writer(self, &mut counter)?;
+        Ok(counter.into_count())
+    }
+}
+
+impl encode::Decodable for PeginWitness {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        match encoding::decode_from_read_unbuffered(d) {
+            Ok(res) => Ok(res),
+            Err(encoding::ReadError::Io(e)) => Err(encode::Error::Io(e)),
+            Err(encoding::ReadError::Decode(e)) => Err(encode::Error::PeginWitness(e)),
+        }
+    }
+}
+
+impl encode::Encodable for PeginWitness {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        match self.inner {
+            Some(ref wit) => wit.consensus_encode(e),
+            None => 0u8.consensus_encode(e),
+        }
+    }
+}
diff --git a/src/transaction/witness.rs b/src/transaction/witness.rs
new file mode 100644
index 00000000..e079d476
--- /dev/null
+++ b/src/transaction/witness.rs
@@ -0,0 +1,1721 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! A witness.
+//!
+//! This module contains the [`Witness`] struct and related methods to operate on it
+
+use core::fmt;
+use core::convert::{TryFrom as _, TryInto as _};
+use core::iter::FromIterator;
+use core::ops::Index;
+use std::{rc, sync};
+
+#[cfg(doc)]
+use crate::encoding::Decoder4;
+use crate::encoding::{
+    self, BytesEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder as _, DecoderStatus,
+    Encoder2,
+};
+use internals::slice::SliceExt;
+
+#[cfg(doc)]
+use crate::TxIn;
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(no_inline)]
+pub use self::error::{UnexpectedEofError, WitnessDecoderError};
+
+use self::error::WitnessDecoderErrorInner;
+
+/// Maximum number of items in a witness stack.
+///
+/// This is an anti-DoS limit based on Bitcoin's 4MB block weight limit.
+/// Witness data is part of transactions, which are part of blocks, so witness
+/// items (assuming 1-byte per item) cannot exceed what fits in a block.
+const MAX_WITNESS_STACK_ITEMS: usize = 4_000_000;
+
+/// Maximum byte size of a single witness stack item.
+///
+/// This is an anti-DoS limit based on Bitcoin's 4MB block weight limit.
+/// Witness data is part of transactions, which are part of blocks, so a
+/// single witness item cannot exceed what fits in a block.
+const MAX_WITNESS_ITEM_SIZE: usize = 4_000_000;
+
+/// The Witness is the data used to unlock bitcoin since the [SegWit upgrade].
+///
+/// Can be logically seen as an array of bytestrings, i.e. `Vec<Vec<u8>>`, and it is serialized on the wire
+/// in that format. You can convert between this type and `Vec<Vec<u8>>` by using [`Witness::from_slice`]
+/// and [`Witness::to_vec`].
+///
+/// For serialization and deserialization performance it is stored internally as a single `Vec`,
+/// saving some allocations.
+///
+/// [SegWit upgrade]: <https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki>
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Witness {
+    /// Contains the witness `Vec<Vec<u8>>` serialization.
+    ///
+    /// 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.
+    ///
+    /// Stored separately (instead of as a compact size encoding in the initial part of content) so
+    /// that methods like [`Witness::push`] don't have to shift the entire array.
+    witness_elements: usize,
+
+    /// This is the valid index pointing to the beginning of the index area.
+    ///
+    /// Said another way, this is the total length of all witness elements serialized (without the
+    /// element count but with their sizes serialized as compact size).
+    indices_start: usize,
+}
+
+impl Witness {
+    /// Constructs a new empty [`Witness`].
+    #[inline]
+    pub const fn new() -> Self {
+        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.
+    pub fn from_slice<T: AsRef<[u8]>>(slice: &[T]) -> Self {
+        let witness_elements = slice.len();
+        let index_size = witness_elements * 4;
+        let content_size = slice
+            .iter()
+            .map(|elem| elem.as_ref().len() + CompactSizeEncoder::encoded_size(elem.as_ref().len()))
+            .sum();
+
+        let mut content = vec![0u8; content_size + index_size];
+        let mut cursor = 0usize;
+        for (i, elem) in slice.iter().enumerate() {
+            encode_cursor(&mut content, content_size, i, cursor);
+            let encoded = crate::compact_size_encode(elem.as_ref().len());
+            let encoded_size = encoded.as_slice().len();
+            content[cursor..cursor + encoded_size].copy_from_slice(encoded.as_slice());
+            cursor += encoded_size;
+            content[cursor..cursor + elem.as_ref().len()].copy_from_slice(elem.as_ref());
+            cursor += elem.as_ref().len();
+        }
+
+        Self { witness_elements, content, indices_start: content_size }
+    }
+
+    /// Convenience method to create an array of byte-arrays from this witness.
+    #[inline]
+    pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(<[u8]>::to_vec).collect() }
+
+    /// Returns `true` if the witness contains no element.
+    #[inline]
+    pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
+
+    /// Returns a struct implementing [`Iterator`].
+    #[must_use = "iterators are lazy and do nothing unless consumed"]
+    #[inline]
+    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 const fn len(&self) -> usize { self.witness_elements }
+
+    /// Returns the number of bytes this witness contributes to a transaction's total size.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
+    pub fn size(&self) -> usize {
+        let mut size: usize = 0;
+
+        size += CompactSizeEncoder::encoded_size(self.witness_elements);
+        size += self
+            .iter()
+            .map(|witness_element| {
+                let len = witness_element.len();
+                CompactSizeEncoder::encoded_size(len) + len
+            })
+            .sum::<usize>();
+
+        size
+    }
+
+    /// Clears the witness.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.content.clear();
+        self.witness_elements = 0;
+        self.indices_start = 0;
+    }
+
+    /// 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());
+    }
+
+    /// 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;
+        let encoded = crate::compact_size_encode(new_element.len());
+        let encoded_size = encoded.as_slice().len();
+        let current_content_len = self.content.len();
+        let new_item_total_len = encoded_size + new_element.len();
+        self.content.resize(current_content_len + new_item_total_len + 4, 0);
+
+        self.content[previous_content_end..].rotate_right(new_item_total_len);
+        self.indices_start += new_item_total_len;
+        encode_cursor(
+            &mut self.content,
+            self.indices_start,
+            self.witness_elements - 1,
+            previous_content_end,
+        );
+
+        let end_compact_size = previous_content_end + encoded_size;
+        self.content[previous_content_end..end_compact_size].copy_from_slice(encoded.as_slice());
+        self.content[end_compact_size..end_compact_size + new_element.len()]
+            .copy_from_slice(new_element);
+    }
+
+    /// Returns the last element in the witness, if any.
+    #[inline]
+    pub fn last(&self) -> Option<&[u8]> { self.get_back(0) }
+
+    /// Retrieves an element from the end of the witness by its reverse index.
+    ///
+    /// `index` is 0-based from the end, where 0 is the last element, 1 is the second-to-last, etc.
+    ///
+    /// Returns `None` if the requested index is beyond the witness's elements.
+    ///
+    /// # Examples
+    /// ```
+    /// use elements::Witness;
+    ///
+    /// let mut witness = Witness::new();
+    /// witness.push(b"A");
+    /// witness.push(b"B");
+    /// witness.push(b"C");
+    /// witness.push(b"D");
+    ///
+    /// assert_eq!(witness.get_back(0), Some(b"D".as_slice()));
+    /// assert_eq!(witness.get_back(1), Some(b"C".as_slice()));
+    /// assert_eq!(witness.get_back(2), Some(b"B".as_slice()));
+    /// assert_eq!(witness.get_back(3), Some(b"A".as_slice()));
+    /// assert_eq!(witness.get_back(4), None);
+    /// ```
+    pub fn get_back(&self, index: usize) -> Option<&[u8]> {
+        if self.witness_elements <= index {
+            None
+        } else {
+            self.get(self.witness_elements - 1 - index)
+        }
+    }
+
+    /// Returns a specific element from the witness by its index, if any.
+    #[inline]
+    pub fn get(&self, index: usize) -> Option<&[u8]> {
+        let pos = decode_cursor(&self.content, self.indices_start, index)?;
+
+        let mut slice = &self.content[pos..]; // Start of element.
+        let element_len = decode_unchecked(&mut slice);
+        let end = cast_to_usize_if_valid(element_len)?;
+        Some(&slice[..end])
+    }
+
+    /// Constructs a new witness from a list of hex strings.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if any of the hex strings are invalid.
+    pub fn from_hex<I, T>(iter: I) -> Result<Self, hex::DecodeVariableLengthBytesError>
+    where
+        I: IntoIterator<Item = T>,
+        T: AsRef<str>,
+    {
+        let result = iter
+            .into_iter()
+            .map(|hex_str| crate::hex::decode_to_vec(hex_str.as_ref()))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(Self::from_slice(&result))
+    }
+}
+
+/// Correctness Requirements: value must always fit within u32
+// This is duplicated in `bitcoin::blockdata::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")));
+}
+
+#[inline]
+fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<usize> {
+    let start = start_of_indices + index * 4;
+    let pos = bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes))?;
+    usize::try_from(pos).ok()
+}
+
+impl encoding::Encode for Witness {
+    type Encoder<'e>
+        = WitnessEncoder<'e>
+    where
+        Self: 'e;
+
+    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::new(Encoder2::new(num_elements, witness_elements))
+    }
+}
+
+impl encoding::Decode for Witness {
+    type Decoder = WitnessDecoder;
+}
+
+encoding::encoder_newtype_exact! {
+    /// The encoder for the [`Witness`] type.
+    #[derive(Debug, Clone)]
+    pub struct WitnessEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+}
+
+/// The decoder for the [`Witness`] type.
+#[derive(Debug, Clone)]
+pub struct WitnessDecoder {
+    /// The single buffer that will become the Witness content.
+    /// The index entries are written in [`Self::end`].
+    content: Vec<u8>,
+    /// 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(),
+            witness_elements: None,
+            witness_count_decoder: CompactSizeDecoder::new_with_limit(MAX_WITNESS_STACK_ITEMS),
+            element_idx: 0,
+            element_length_decoder: CompactSizeDecoder::new_with_limit(MAX_WITNESS_ITEM_SIZE),
+            element_bytes_remaining: None,
+        }
+    }
+}
+
+impl Default for WitnessDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for WitnessDecoder {
+    type Output = Witness;
+    type Error = WitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        use WitnessDecoderError as E;
+        use 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)))?
+                .needs_more()
+            {
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            // 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(DecoderStatus::Ready);
+            }
+
+            // Allocate space for the 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.
+            self.content.reserve(128);
+        }
+
+        let Some(witness_elements) = self.witness_elements else {
+            unreachable!("witness_elements must be Some after initial read")
+        };
+
+        // Read witness elements.
+        loop {
+            // Check if we're done processing all elements.
+            if self.element_idx >= witness_elements {
+                return Ok(DecoderStatus::Ready);
+            }
+
+            if bytes.is_empty() {
+                return Ok(DecoderStatus::NeedsMore);
+            }
+
+            // 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 can_copy = bytes.len().min(bytes_to_read);
+                // To avoid reallocating the index space in `end()` we reserve it here, the moment
+                // the final element's data is copied.
+                if can_copy == bytes_to_read && self.element_idx + 1 == witness_elements {
+                    self.content.reserve_exact(can_copy + witness_elements * 4);
+                }
+                self.content.extend_from_slice(&bytes[..can_copy]);
+                *bytes = &bytes[can_copy..];
+                let remaining = bytes_to_read - can_copy;
+
+                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)))?
+                    .needs_more()
+                {
+                    return Ok(DecoderStatus::NeedsMore);
+                }
+
+                // 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)))?;
+
+                // keep the element length prefix in the content area.
+                let encoded_compact_size = crate::compact_size_encode(element_length);
+                self.content.extend_from_slice(encoded_compact_size.as_slice());
+
+                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;
+        use 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 {
+            // `content` now holds the complete content area (all element bytes have been already received)
+            // The index area begins at its current end.
+            let indices_start = self.content.len();
+
+            // Build the index area by walking the content area
+            // This is the only allocation sized by the element count, and it happens only here
+            self.content.reserve(witness_elements * 4);
+            let mut read_pos = 0;
+            for _ in 0..witness_elements {
+                let offset = u32::try_from(read_pos).expect("larger than u32");
+                let (element_length, prefix_size) = {
+                    let mut slice = &self.content[read_pos..indices_start];
+                    let before = slice.len();
+                    let element_length = decode_unchecked(&mut slice);
+                    (element_length, before - slice.len())
+                };
+                let data_len = usize::try_from(element_length).expect("element data is present");
+                read_pos += prefix_size + data_len;
+                self.content.extend_from_slice(&offset.to_ne_bytes());
+            }
+
+            Ok(Witness { content: self.content, witness_elements, indices_start })
+        } 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,
+            }
+        }
+    }
+}
+
+// Note: we use `Borrow` in the following `PartialEq` impls specifically because of its additional
+// constraints on equality semantics.
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<[T]> for Witness {
+    fn eq(&self, rhs: &[T]) -> bool {
+        if self.len() != rhs.len() {
+            return false;
+        }
+        self.iter().zip(rhs).all(|(left, right)| left == right.borrow())
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<&[T]> for Witness {
+    fn eq(&self, rhs: &&[T]) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == **self }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<[T; N]> for Witness {
+    fn eq(&self, rhs: &[T; N]) -> bool { *self == *rhs.as_slice() }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<&[T; N]> for Witness {
+    fn eq(&self, rhs: &&[T; N]) -> bool { *self == *rhs.as_slice() }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T; N] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T; N] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == **self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Vec<T>> for Witness {
+    fn eq(&self, rhs: &Vec<T>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Vec<T> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Box<[T]>> for Witness {
+    fn eq(&self, rhs: &Box<[T]>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Box<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<rc::Rc<[T]>> for Witness {
+    fn eq(&self, rhs: &rc::Rc<[T]>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for rc::Rc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<sync::Arc<[T]>> for Witness {
+    fn eq(&self, rhs: &sync::Arc<[T]>) -> bool { *self == **rhs }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for sync::Arc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+/// 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` 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 {
+        let total_bytes: usize = self.iter().map(<[u8]>::len).sum();
+
+        f.debug_struct("Witness")
+            .field("num_elements", &self.witness_elements)
+            .field("total_bytes", &total_bytes)
+            .field(
+                "elements",
+                &WrapDebug(|f| {
+                    f.debug_list().entries(self.iter().map(hex::DisplayHex::as_hex)).finish()
+                }),
+            )
+            .finish()
+    }
+}
+
+/// An iterator returning individual witness elements.
+#[derive(Clone)]
+pub struct Iter<'a> {
+    inner: &'a [u8],
+    indices_start: usize,
+    current_index: usize,
+}
+
+impl Index<usize> for Witness {
+    type Output = [u8];
+
+    #[track_caller]
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output { self.get(index).expect("out of bounds") }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a [u8];
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = decode_cursor(self.inner, self.indices_start, self.current_index)?;
+        let mut slice = &self.inner[index..]; // Start of element.
+        let element_len = decode_unchecked(&mut slice);
+        let end = cast_to_usize_if_valid(element_len)?;
+        self.current_index += 1;
+        Some(&slice[..end])
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let total_count = (self.inner.len() - self.indices_start) / 4;
+        let remaining = total_count - self.current_index;
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for Iter<'_> {}
+
+impl<'a> IntoIterator for &'a Witness {
+    type IntoIter = Iter<'a>;
+    type Item = &'a [u8];
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { self.iter() }
+}
+
+impl<T: AsRef<[u8]>> FromIterator<T> for Witness {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut decoder = WitnessDecoder::new();
+
+        // We can't count the number of witness elements without consuming the iterator.
+        // So instead, we build up the full push_bytes buffer and then push it all at once.
+        // We'll start with a 256 byte buffer to double the initial WitnessDecoder size.
+        let mut buffer = Vec::with_capacity(256);
+        let mut witness_elements = 0;
+
+        // For each witness element, the decoder expects an element length, followed by
+        // the data itself. The iterator's yielded elements do not include the length prefix,
+        // so we add them.
+        for elem in iter {
+            let encoded = crate::compact_size_encode(elem.as_ref().len());
+            buffer.extend_from_slice(encoded.as_slice());
+            buffer.extend_from_slice(elem.as_ref());
+            witness_elements += 1;
+        }
+
+        let witness_count = crate::compact_size_encode(witness_elements);
+        let _ = decoder.push_bytes(&mut witness_count.as_slice());
+
+        let _ = decoder.push_bytes(&mut buffer.as_slice());
+
+        decoder.end().expect("witness_elements in decoder is equal to number of provided elements")
+    }
+}
+
+// Serde keep backward compatibility with old Vec<Vec<u8>> format
+#[cfg(feature = "serde")]
+impl serde::Serialize for Witness {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+
+        let human_readable = serializer.is_human_readable();
+        let mut seq = serializer.serialize_seq(Some(self.witness_elements))?;
+
+        // Note that the `Iter` strips the varints out when iterating.
+        for elem in self {
+            if human_readable {
+                seq.serialize_element(&SerializeBytesAsHex(elem))?;
+            } else {
+                seq.serialize_element(&elem)?;
+            }
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Witness {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor; // Human-readable visitor.
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = Witness;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a sequence of hex arrays")
+            }
+
+            fn visit_seq<A: serde::de::SeqAccess<'de>>(
+                self,
+                mut a: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut ret = match a.size_hint() {
+                    Some(len) => Vec::with_capacity(len),
+                    None => Vec::new(),
+                };
+
+                while let Some(elem) = a.next_element::<String>()? {
+                    let vec = hex::decode_to_vec(&elem).map_err(serde::de::Error::custom)?;
+                    ret.push(vec);
+                }
+                Ok(Witness::from_slice(&ret))
+            }
+        }
+
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_seq(Visitor)
+        } else {
+            let vec: Vec<Vec<u8>> = serde::Deserialize::deserialize(deserializer)?;
+            Ok(Self::from_slice(&vec))
+        }
+    }
+}
+
+impl From<Vec<Vec<u8>>> for Witness {
+    #[inline]
+    fn from(vec: Vec<Vec<u8>>) -> Self { Self::from_slice(&vec) }
+}
+
+impl From<&[&[u8]]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8]]) -> Self { Self::from_slice(slice) }
+}
+
+impl From<&[Vec<u8>]> for Witness {
+    #[inline]
+    fn from(slice: &[Vec<u8>]) -> Self { Self::from_slice(slice) }
+}
+
+impl From<Vec<&[u8]>> for Witness {
+    #[inline]
+    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 { Self::from_slice(&arr) }
+}
+
+impl<const N: usize> From<&[&[u8]; N]> for Witness {
+    #[inline]
+    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 { Self::from_slice(slice) }
+}
+
+impl<const N: usize> From<&[&[u8; N]]> for Witness {
+    #[inline]
+    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 { 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 { 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 { 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 { Self::from_slice(slice) }
+}
+
+impl Default for Witness {
+    #[inline]
+    fn default() -> Self { Self::new() }
+}
+
+/// 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()
+}
+
+/// Gets the compact size encoded value from `slice` and moves slice past the encoding.
+///
+/// Caller to guarantee that the encoding is well formed. Well formed is defined as:
+///
+/// * Being at least long enough.
+/// * Containing a minimal encoding.
+///
+/// # Panics
+///
+/// * 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).
+fn decode_unchecked(slice: &mut &[u8]) -> u64 {
+    assert!(!slice.is_empty(), "tried to decode an empty slice");
+
+    match slice[0] {
+        0xFF => {
+            const SIZE: usize = 9;
+            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]);
+
+            let v = u64::from_le_bytes(bytes);
+            debug_assert!(v > u32::MAX.into(), "non-minimal encoding of a u64");
+            *slice = &slice[SIZE..];
+            v
+        }
+        0xFE => {
+            const SIZE: usize = 5;
+            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]);
+
+            let v = u32::from_le_bytes(bytes);
+            debug_assert!(v > u16::MAX.into(), "non-minimal encoding of a u32");
+            *slice = &slice[SIZE..];
+            u64::from(v)
+        }
+        0xFD => {
+            const SIZE: usize = 3;
+            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]);
+
+            let v = u16::from_le_bytes(bytes);
+            debug_assert!(v >= 0xFD, "non-minimal encoding of a u16");
+            *slice = &slice[SIZE..];
+            u64::from(v)
+        }
+        n => {
+            *slice = &slice[1..];
+            u64::from(n)
+        }
+    }
+}
+
+/// A wrapper for a function that implements `Debug`.
+struct WrapDebug<F: Fn(&mut fmt::Formatter) -> fmt::Result>(pub F);
+
+impl<F: Fn(&mut fmt::Formatter) -> fmt::Result> fmt::Debug for WrapDebug<F> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { (self.0)(f) }
+}
+
+/// Serializes a byte slice using the `hex` crate.
+#[cfg(feature = "serde")]
+struct SerializeBytesAsHex<'a>(pub &'a [u8]);
+
+#[cfg(feature = "serde")]
+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()))
+    }
+}
+
+/// Error types for witness data.
+pub mod error {
+    use core::convert::Infallible;
+    use core::fmt;
+
+    use crate::encoding::CompactSizeDecoderError;
+
+    /// An error when consensus decoding a [`Witness`].
+    ///
+    /// [`Witness`]: super::Witness
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct WitnessDecoderError(pub(super) WitnessDecoderErrorInner);
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub(super) 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(..) => f.write_str("vec decoder error"),
+                E::UnexpectedEof(..) => f.write_str("decoder error"),
+            }
+        }
+    }
+
+    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.
+        pub(super) missing_elements: usize,
+    }
+
+    impl From<Infallible> for UnexpectedEofError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for UnexpectedEofError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(f, "not enough witness elements for decoder, missing {}", self.missing_elements)
+        }
+    }
+
+    impl std::error::Error for UnexpectedEofError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            let Self { missing_elements: _ } = self;
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::error::Error as _;
+
+    use encoding::check_encode;
+    use encoding::Decode as _;
+
+    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_single_empty_element() {
+        let mut got = Witness::new();
+        got.push([]);
+        let want = single_empty_element();
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn push() {
+        // Sanity check default.
+        let mut witness = Witness::default();
+        assert!(witness.is_empty());
+        assert_eq!(witness.last(), None);
+        assert_eq!(witness.get_back(1), None);
+
+        assert_eq!(witness.get(0), None);
+        assert_eq!(witness.get(1), None);
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        // Push a single byte element onto the witness stack.
+        let push = [11_u8];
+        witness.push(push);
+        assert!(!witness.is_empty());
+
+        assert_eq!(witness, [[11_u8]]);
+
+        let element_0 = push.as_slice();
+        assert_eq!(element_0, &witness[0]);
+
+        assert_eq!(witness.get_back(1), None);
+        assert_eq!(witness.last(), Some(element_0));
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), None);
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        // Now push 2 byte element onto the witness stack.
+        let push = [21u8, 22u8];
+        witness.push(push);
+
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22]]);
+
+        let element_1 = push.as_slice();
+        assert_eq!(element_1, &witness[1]);
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), Some(element_1));
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        assert_eq!(witness.get_back(1), Some(element_0));
+        assert_eq!(witness.last(), Some(element_1));
+
+        // Now push another 2 byte element onto the witness stack.
+        let push = [31u8, 32u8];
+        witness.push(push);
+
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22], &[31, 32]]);
+
+        let element_2 = push.as_slice();
+        assert_eq!(element_2, &witness[2]);
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), Some(element_1));
+        assert_eq!(witness.get(2), Some(element_2));
+        assert_eq!(witness.get(3), None);
+
+        assert_eq!(witness.get_back(2), Some(element_0));
+        assert_eq!(witness.get_back(1), Some(element_1));
+        assert_eq!(witness.last(), Some(element_2));
+    }
+
+    #[test]
+    fn exact_sized_iterator() {
+        let arbitrary_element = [1_u8, 2, 3];
+        let num_pushes = 5; // Somewhat arbitrary.
+
+        let mut witness = Witness::default();
+
+        for i in 0..num_pushes {
+            assert_eq!(witness.iter().len(), i);
+            witness.push(arbitrary_element);
+        }
+
+        let mut iter = witness.iter();
+        for i in (0..=num_pushes).rev() {
+            assert_eq!(iter.len(), i);
+            iter.next();
+        }
+    }
+
+    #[test]
+    fn witness_from_impl() {
+        // Test From implementations with the same 2 elements
+        let vec = vec![vec![11], vec![21, 22]];
+        let slice_vec: &[Vec<u8>] = &vec;
+        let slice_slice: &[&[u8]] = &[&[11u8], &[21, 22]];
+        let vec_slice: Vec<&[u8]> = vec![&[11u8], &[21, 22]];
+
+        let witness_vec_vec = Witness::from(vec.clone());
+        let witness_slice_vec = Witness::from(slice_vec);
+        let witness_slice_slice = Witness::from(slice_slice);
+        let witness_vec_slice = Witness::from(vec_slice);
+
+        let mut expected = Witness::from_slice(&vec);
+        assert_eq!(expected.len(), 2);
+        assert_eq!(expected.to_vec(), vec);
+
+        assert_eq!(witness_vec_vec, expected);
+        assert_eq!(witness_slice_vec, expected);
+        assert_eq!(witness_slice_slice, expected);
+        assert_eq!(witness_vec_slice, expected);
+
+        // Test clear method
+        expected.clear();
+        assert!(expected.is_empty());
+    }
+
+    #[test]
+    fn witness_from_array_impl() {
+        const DATA_1: [u8; 3] = [1, 2, 3];
+        const DATA_2: [u8; 3] = [4, 5, 6];
+        let witness = Witness::from_slice(&[DATA_1, DATA_2]);
+
+        let witness_from_array_ref = Witness::from(&[DATA_1, DATA_2]);
+        let witness_from_array_of_refs = Witness::from([&DATA_1, &DATA_2]);
+        let witness_from_ref_to_array_of_refs = Witness::from(&[&DATA_1, &DATA_2]);
+        let witness_from_fixed_array = Witness::from([DATA_1, DATA_2]);
+        let witness_from_slice_of_refs = Witness::from(&[&DATA_1, &DATA_2][..]);
+        let witness_from_nested_array = Witness::from(&[DATA_1, DATA_2][..]);
+
+        assert_eq!(witness_from_array_ref, witness);
+        assert_eq!(witness_from_array_of_refs, witness);
+        assert_eq!(witness_from_ref_to_array_of_refs, witness);
+        assert_eq!(witness_from_fixed_array, witness);
+        assert_eq!(witness_from_slice_of_refs, witness);
+        assert_eq!(witness_from_nested_array, witness);
+    }
+
+    #[test]
+    fn witness_size() {
+        let mut witness = Witness::new();
+        let want = 1; // Number of elements compact size encoded.
+        assert_eq!(witness.size(), want);
+
+        witness.push([1, 2, 3]);
+        let want = 5; // 1 + 1 + 3
+        assert_eq!(witness.size(), want);
+
+        witness.push([4, 5]);
+        let want = 8; // 5 + 1 + 2
+        assert_eq!(witness.size(), want);
+    }
+
+    #[test]
+    fn partial_eq() {
+        const EMPTY_BYTES: &[u8] = &[];
+        const DATA_1: &[u8] = &[42];
+        const DATA_2: &[u8] = &[42, 21];
+
+        macro_rules! ck {
+            ($witness:expr, $container:expr, $different:expr) => {{
+                let witness = $witness;
+                let container = $container;
+                let different = $different;
+
+                assert_eq!(witness, container, stringify!($container));
+                assert_eq!(container, witness, stringify!($container));
+
+                assert_ne!(witness, different, stringify!($container));
+                assert_ne!(different, witness, stringify!($container));
+            }};
+        }
+
+        // &[T]
+        let container: &[&[u8]] = &[EMPTY_BYTES];
+        let different: &[&[u8]] = &[DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        let container: &[&[u8]] = &[DATA_1];
+        let different: &[&[u8]] = &[DATA_2];
+        ck!(Witness::from(container), container, different);
+
+        // &[T; N]
+        let container: &[&[u8]; 2] = &[DATA_1, DATA_2];
+        let different: &[&[u8]; 2] = &[DATA_2, DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        // [&[T]; N]
+        let container: [&[u8]; 2] = [DATA_1, DATA_2];
+        let different: [&[u8]; 2] = [DATA_2, DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        // Vec<T>
+        let container: Vec<&[u8]> = vec![DATA_1, DATA_2];
+        let different: Vec<&[u8]> = vec![DATA_2, DATA_1];
+        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::from(&*container), container, different);
+
+        // Rc<[T]>
+        let container: rc::Rc<[&[u8]]> = vec![DATA_1, DATA_2].into();
+        let different: rc::Rc<[&[u8]]> = vec![DATA_2, DATA_1].into();
+        ck!(Witness::from(&*container), container, different);
+
+        // Arc<[T]>
+        let container: sync::Arc<[&[u8]]> = vec![DATA_1, DATA_2].into();
+        let different: sync::Arc<[&[u8]]> = vec![DATA_2, DATA_1].into();
+        ck!(Witness::from(&*container), container, different);
+    }
+
+    #[test]
+    fn partial_eq_for_slice() {
+        let witness = Witness::from_slice(&[vec![1, 2, 3], vec![4, 5, 6]]);
+        let container: &[Vec<u8>] = &[vec![1, 2, 3], vec![4, 5, 6]];
+        let different: &[Vec<u8>] = &[vec![1, 2], vec![4, 5]];
+
+        // Explicitly dereference the slice to invoke the `[T]` implementation.
+        assert_eq!(*container, witness);
+        assert_ne!(*different, witness);
+    }
+
+    #[test]
+    fn partial_eq_len_mismatch() {
+        let witness = Witness::from_slice(&[&[1u8][..]]);
+        let rhs = vec![vec![1u8], vec![2u8]];
+        assert_ne!(witness, rhs.as_slice());
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_bincode_backward_compatibility() {
+        let old_witness_format = vec![vec![0u8], vec![2]];
+        let new_witness_format = Witness::from_slice(&old_witness_format);
+
+        let old = bincode::serialize(&old_witness_format).unwrap();
+        let new = bincode::serialize(&new_witness_format).unwrap();
+
+        assert_eq!(old, new);
+    }
+
+    #[cfg(feature = "serde")]
+    fn arbitrary_witness() -> Witness {
+        let mut witness = Witness::default();
+
+        witness.push([0_u8]);
+        witness.push([1_u8; 32]);
+        witness.push([2_u8; 72]);
+
+        witness
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_bincode_roundtrips() {
+        let original = arbitrary_witness();
+        let ser = bincode::serialize(&original).unwrap();
+        let roundtrip: Witness = bincode::deserialize(&ser).unwrap();
+        assert_eq!(roundtrip, original);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_human_roundtrips() {
+        let original = arbitrary_witness();
+        let ser = serde_json::to_string(&original).unwrap();
+        let roundtrip: Witness = serde_json::from_str(&ser).unwrap();
+        assert_eq!(roundtrip, original);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_human() {
+        let witness = Witness::from_slice(&[vec![0u8, 123, 75], vec![2u8, 6, 3, 7, 8]]);
+        let json = serde_json::to_string(&witness).unwrap();
+        assert_eq!(json, r#"["007b4b","0206030708"]"#);
+    }
+
+    #[test]
+    fn test_witness_from_iterator() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let bytes3 = [6u8, 7, 8, 9];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        // Use FromIterator directly
+        let witness1 = Witness::from_iter(data);
+
+        // Create a witness manually for comparison
+        let mut witness2 = Witness::new();
+        for item in &data {
+            witness2.push(item);
+        }
+        assert_eq!(witness1, witness2);
+        assert_eq!(witness1.len(), witness2.len());
+        assert_eq!(witness1.to_vec(), witness2.to_vec());
+
+        // Test with collect
+        let bytes4 = [0u8, 123, 75];
+        let bytes5 = [2u8, 6, 3, 7, 8];
+        let data = [bytes4.to_vec(), bytes5.to_vec()];
+        let witness3: Witness = data.iter().collect();
+        assert_eq!(witness3.len(), 2);
+        assert_eq!(witness3.to_vec(), data);
+
+        // Test with empty iterator
+        let empty_data: Vec<Vec<u8>> = vec![];
+        let witness4: Witness = empty_data.iter().collect();
+        assert!(witness4.is_empty());
+    }
+
+    #[test]
+    fn test_from_hex() {
+        let hex_strings = [
+            "30440220703350f1c8be5b41b4cb03b3b680c4f3337f987514a6b08e16d5d9f81e9b5f72022018fb269ba5b82864c0e1edeaf788829eb332fe34a859cc1f99c4a02edfb5d0df01",
+            "0208689fe2cca52d8726cefaf274de8fa61d5faa5e1058ad35b49fb194c035f9a4",
+        ];
+
+        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);
+
+        check_encode(&witness, &[2u8, 3u8, 1, 2, 3, 2, 4, 5]);
+    }
+
+    #[test]
+    fn encode_empty() {
+        let witness = Witness::default();
+
+        let want = [0x00];
+        let got = encoding::encode_to_vec(&witness);
+
+        assert_eq!(&got, &want);
+    }
+
+    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]
+    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]
+    #[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]
+    fn decode_max_length() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(crate::compact_size_encode(1usize).as_slice());
+        encoded.extend_from_slice(crate::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);
+    }
+
+    #[test]
+    fn decode_length_prefix_error() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(crate::compact_size_encode(1usize).as_slice());
+        encoded.extend_from_slice(crate::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(_))
+        ));
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+
+    #[test]
+    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().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 0);
+        assert!(witness.is_empty());
+    }
+
+    #[test]
+    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().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[0xABu8, 0xCD][..]);
+    }
+
+    #[test]
+    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().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[] as &[u8]);
+    }
+
+    #[test]
+    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().is_ready());
+        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]
+    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().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    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().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    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().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    fn decoder_read_limit() {
+        let mut decoder = Witness::decoder();
+        // witness_count_decoder is CompactSize: needs 1 byte.
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Set witness count = 1.
+        let mut bytes = [0x01u8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // element_length_decoder is CompactSize: needs 1 byte..
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Provide only first byte of a 3 byte CompactSize.
+        let mut bytes = [0xFDu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 2);
+
+        // Set element length to 500 (0x01F4 little-endian).
+        let mut bytes = [0xF4u8, 0x01].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // Decoder now reads element data and the limit becomes the element length.
+        assert_eq!(decoder.read_limit(), 500);
+
+        // Provide 1 byte of element data decreasing the read limit by 1.
+        let mut bytes = [0xAAu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 499);
+    }
+
+    #[test]
+    fn decoder_end_without_witness_count_errors() {
+        let err = WitnessDecoder::new().end().unwrap_err();
+        assert!(matches!(
+            err,
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(UnexpectedEofError {
+                missing_elements: 0
+            }))
+        ));
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+
+    #[test]
+    fn decoder_unexpected_eof_error() {
+        let mut decoder = WitnessDecoder::new();
+        let mut slice = [0x01].as_slice(); // witness element count = 1.
+        assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
+
+        let inner = match decoder.end().unwrap_err() {
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(inner)) => inner,
+            err => panic!("unexpected error: {}", err),
+        };
+        assert!(!inner.to_string().is_empty());
+    }
+
+    #[test]
+    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().is_ready());
+
+        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 iter_next_none_if_cursor_decode_fails() {
+        let witness = Witness { content: vec![], witness_elements: 1, indices_start: 0 };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    fn iter_next_none_if_element_len_too_big() {
+        // Element length = 4_000_001 which is larger than MAX_VEC_SIZE (4_000_000).
+        let mut content = vec![0xFE];
+        content.extend_from_slice(&4_000_001u32.to_le_bytes());
+        let indices_start = content.len();
+        content.extend_from_slice(&u32::to_ne_bytes(0));
+
+        let witness = Witness { content, witness_elements: 1, indices_start };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    fn witness_debug() {
+        let witness = Witness::from_slice(&[&[0xAAu8][..]]);
+        let s = format!("{:?}", witness);
+        assert!(!s.is_empty());
+    }
+
+    #[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());
+    }
+
+    #[test]
+    fn decode_value_1_byte() {
+        // Check lower bound, upper bound.
+        for v in [0x00, 0x01, 0x02, 0xFA, 0xFB, 0xFC] {
+            let raw = [v];
+            let mut slice = raw.as_slice();
+            let got = decode_unchecked(&mut slice);
+            assert_eq!(got, u64::from(v));
+            assert!(slice.is_empty());
+        }
+    }
+
+    macro_rules! check_decode {
+        ($($test_name:ident, $size:expr, $want:expr, $encoded:expr);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    let mut slice = $encoded.as_slice();
+                    let got = decode_unchecked(&mut slice);
+                    assert_eq!(got, $want);
+                    assert_eq!(slice.len(), $encoded.len() - $size);
+                }
+            )*
+        }
+    }
+
+    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];
+        decode_from_5_byte_slice_upper_bound, 5, 0xFFFF_FFFF, [0xFE, 0xFF, 0xFF, 0xFF, 0xFF];
+        // 9 byte encoding.
+        decode_from_9_byte_slice_lower_bound, 9, 0x0000_0001_0000_0000, [0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00];
+        decode_from_9_byte_slice_endianness, 9, 0x0123_4567_89AB_CDEF, [0xFF, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01];
+        decode_from_9_byte_slice_upper_bound, 9, u64::MAX, [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+
+        // Check slices that are bigger than the actual encoding.
+        decode_1_byte_from_bigger_slice, 1, 32, [0x20, 0xAB, 0xBC];
+        decode_3_byte_from_bigger_slice, 3, 0xFFFF, [0xFD, 0xFF, 0xFF, 0xAB, 0xBC];
+        decode_5_byte_from_bigger_slice, 5, 0xFFFF_FFFF, [0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xAB, 0xBC];
+        decode_9_byte_from_bigger_slice, 9, u64::MAX, [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xAB, 0xBC];
+    }
+
+    #[test]
+    #[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(expected = "slice too short, expected at least 5 bytes")]
+    // 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();
+        let _ = decode_unchecked(&mut slice);
+    }
+
+    #[test]
+    fn test_dos_protection() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(&[0xFE, 0x00, 0x09, 0x3D, 0x00]); // 4_000_000 (witness count)
+        encoded.extend_from_slice(&[0xFE, 0x00, 0x09, 0x3D, 0x00]); // 4_000_000 (1st element length)
+
+        let mut slice = encoded.as_slice();
+        let mut dec = WitnessDecoder::new();
+
+        assert!(dec.push_bytes(&mut slice).unwrap().needs_more());
+
+        // Only the 1st element length prefix has been written to the content area.
+        // No massive allocation occurred.
+        assert_eq!(dec.content.len(), 5);
+        assert!(dec.content.capacity() < 100_000);
+    }
+}
diff --git a/tests/data/1in2out_pegin.hex b/tests/data/1in2out_pegin.hex
new file mode 100644
index 00000000..697a00b6
--- /dev/null
+++ b/tests/data/1in2out_pegin.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/1in2out_tx.hex b/tests/data/1in2out_tx.hex
new file mode 100644
index 00000000..997a021f
--- /dev/null
+++ b/tests/data/1in2out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/1in3out_tx.hex b/tests/data/1in3out_tx.hex
new file mode 100644
index 00000000..15dd14d1
--- /dev/null
+++ b/tests/data/1in3out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/2in3out_exp.hex b/tests/data/2in3out_exp.hex
new file mode 100644
index 00000000..e4f7fda3
--- /dev/null
+++ b/tests/data/2in3out_exp.hex
@@ -0,0 +1 @@
+0200000001027a2ac82252ab075b902a5515a60c21992b82839a835c3bdd14693df06d2875332c00000000fdffffff7a2ac82252ab075b902a5515a60c21992b82839a835c3bdd14693df06d2875330700000000fdffffff0301230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5dfba001600140dee90a6ee92e97eb19e30961c4c46927efa438101230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000005f5e1000016001419abecb8f7968b453d635050bab49e0534f3f19c01230f4f5d4b7c6fa845806ee4f67713459e1b69e8e60fcee2e4940c7a0d5de1b2010000000000000146000066000000000002473044022052edc38055ef30c6693be717c52cca43348204c27fe1ba0ab64251852bfb4c2d0220785b5236ab203f6332f9f1b68d3f98b55b027e81aa5ef1c7c603140787286c060121031abe2442aa1cefbd14cfccadf68c711946f081e7a146b910761c1f8e61819e9b00000002473044022013e0990cc749151a79635eee180e54fa05cf4282a1360dfaf80b561dabd4f8fe0220164516da7d61c5f813046d5ea3951753db500610c9d00043510650fe7e5e60f80121020a0ed1cbf6cc48ed846996f450760cad708e3c36fe2fa0e878e2f0b3107e910c00000000000000
\ No newline at end of file
diff --git a/tests/data/2in3out_tx.hex b/tests/data/2in3out_tx.hex
new file mode 100644
index 00000000..4c78f13d
--- /dev/null
+++ b/tests/data/2in3out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/2in3out_tx2.hex b/tests/data/2in3out_tx2.hex
new file mode 100644
index 00000000..82a2b7b6
--- /dev/null
+++ b/tests/data/2in3out_tx2.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/2in4out_tx.hex b/tests/data/2in4out_tx.hex
new file mode 100644
index 00000000..eba002ab
--- /dev/null
+++ b/tests/data/2in4out_tx.hex
@@ -0,0 +1 @@
+02000000010265c1a5c421e567eac3408b86002ec2cac34cb11f6c6f0344b53fdb8a2fe5d74200000000171600145b5e93bd6d3db526c212c1001591ffa426f3c8e2feffffffa426ace5b8c930247cf8d5eb770e220185b55e9b8ddd9009b92527d6c36082760100000017160014e0f4711c07626a8d15f78503d47ea13708c82f28feffffff040b85401de91c3f424934652c15b00c87cf64163d8eeca4063f4d5eebb05e6a3e2e098392af4d760ebd5bae99e5f75c6a4e03f867e6a71896d930e209475817e3393b03cd899ea46a41a2a6f60e191531af662920d468c590f62fcacb83ef40fac9586717a914663036ac1af89a04569bee85017a7d0e0bf92332870a88155dace95bcd23494f3535d7a4cfe4c72f6bd382f53074a5f0d61821d6aaa108f4c3bf6e149ddd2a49682ec5fb30acd2eb152104f52cded967f9478cbdb87af603ed9f16cb3306c159c3319fc39b06ddac69822de3c93558dd9f2d6b291767acdb17a91425a191fd044922742b497c097d5288e1c92acb8e870be1436610f55673220ed543f5967d5359ad9f9ff3cfe80391df1ec2d5b742f240095f363836349c5012b7cc6c04dbee67d1f62e057eabe3c93943ea6775f6b470c5032a7078c6eabd65dab31487d6581a742fdfdb88df7119b3f70109ac28e3567dd717a9141b657d7c7b77763dc834fde13cbb8e350739619f87016d521c38ec1ea15734ae22b7c46064412829c0d0579f0a713d1c04ede979026f01000000000000018400009def2b0000000247304402202e7f8a862c5420c55d9cb0ff91bac91e2153178b1c2d412e0acbed5943a802b00220480afaee1a779059141d923bb772ddc2eede0ee4324af86cb2d78c02edb0c045012102084fb12be92676625adc3319b43e1c5292b622ed8e4156a2f14d95dfc8d1e3ea0000000247304402207fac08a34ea8564c44a00367098a07b47b4a0e2f3f0e134d523bfe231e0ab2e10220541d7159571860f2a7996ddbdc4da44bca186091f6a4a513113fd74a52ce7a7c0121038c417286b254c7da2a4b37d13df7ec35c80de8562c64bd08ff21d1598999c1900063020003dda58f718c7f8ed87468cc71771d2763fb31860af6f18ea1c9a7f9b7420fb9ebc6c54676e79d9f77ba5d5f6fa5747d2e560deb927b0de9e8f65977cff567d33391d65aca5b570b5e6c83ec961b81b59b8c78059f4a18cca2aee563cd60208bd9fd4e10603300000000000000019f3afa01366905c9b0eecb5c39bbf271c29bb7ff91e3bb8dd34aa0b3cc27f40473ffa7885da6da0062ce87f57459f2af09788f5cbc520032cddbeb71206e45ab85bc4325f6753b5bbbc9b7313d6c2b400b37fe635b71476737e398e89d2e8e27190015708e4b676a91dbcc8e9572e4da3308b8615231f4320aa90110e5a9cba4c3e3aff22cf6a152acdd81ac520468154fea739f0635c40dc5a95ff49f316a60bd978d76b5390b8f9294e5d0fa2b40e51e4ea2c9d7a402b1a6590ff38d611dd671399bd91f4d0a93ff23b97c24fd088b99211060c43a237293f75f93f6d2ce40e5a94bc6603a28fe358f2bd7c79fcd4df0ca9146ba071e380b1f179d19e08b7a4c845eb7c19a38f6db94a7b89073bd7bed874f767b6719e4300b94545f817e9bacd8c2eefdd626ca633fe8dec35c1def9a59aa618e0bbd7183c7c20bc7a5a5c564659f3d29a72a6ea68b735963e2d25540cc49d6b67b0ce015dd10b083d202fe84b0b368b27a08806bd8044f0460c1e6d0fdfb5bc05a72de7f2d03318759dcb4ae61b8f861ce4b4d3d7c4985d737385e2f171d484a41f7183f51e700f420820eb6789042b74728ec44b4e05cccc92f4cc59b2abc8c3eb35b28111758d93b08f8b94c4c961b203b7305f3e4e59c71cf6ede9898908ee0902df5324482597e75fb7165df7295da777e042f2b5ac67637f24be0e0e3234662fb4a2de6fc72e9ffabafc6f9593f3f0ed47fd412e2346a4ae8dc3538f768e97bd594d2cd07abdb7efebda3a3a802f7571976592041d298b6d8e80a5cd0013854896866f1f2f61e6fa270e4a77a5cdbdb77f39a351743b83168fffa71783b456aea359fd6d442014b0df9a784ad3a78cf67809c4700d52f0bc0c83860f2733683bc0bf691d59747044055517e901135bdbb88a1f6e4db57b96820d2f0d76fcac2e0ed7da046cfa11773d6955a419c6080b09320196c4319ee1073dd007ffef828efd87c7345423e3015f13edf51debb05591eb8c954e8f3dee615cf831c1666c6992d0997f0184b086711ddf98eb97417655076122229983eb780a7d607d1c42df1cd1fbbb893cda25ed0def925548f97db8b97899218f11ba5d8f8856f3b6f695b84860ece94fab3969fcdaffc52034bef70461aa39cec4a6cd3f4c37a72aa01116d0494f1b6d6604f240585a1fa064479de86133e44369bc102616410c58c67b86b767c6192c4db3f0a8e1260d9ea979d63e80320b998a5ee32e564f7e945eb6819931c46741f9f8ebd20c683b3454336a073beb843d70c8f7ef22aa08584e6a7723df645710dd246296ef761417abcb561c93709af650b5eb41a31d8fb8e17ca8dcd024539d0c9adbef5c2d7b907ba91b46422c25f5ab8fdaf23d735b219e6ea602eaf7bd5bbfd8dfbc77db3e2105070ed3d9377b5a7e679f1ea5c92ec81816cbb35fff7c3b26289d25cd1d59411da40a7dbf3dbda1e0eb5e53b5c462d28b4a197dd852c27e4bd470dfbf46d62cf0a699f04f482951ffa15c2160579139e4c8b22b124fbe87ba5b727361127c1bd48818fc193cb89e32aaa1010d56b73f15160c332dca9327b5eea4562528d606e218ce035592e25143a1c16cb516b22d3dd01cd26cb5fd355898268f0c3712f1f070c1ac93f64a2b0006203b893ff4b53dca0974bb783571c7d7ce7f1a2805d50ebddcc7814142935e50939d0eb401718622a0280632d9157e84d77f2102f8fd9b97af8cbe848b5f6acb7af6a16a8377eb7cf505f8c31918c1a2e917bbe93cea7c3dc54e17fb2eef2771706955dc815d5355ee7eb3e81ee795052a2026609067d5d37087b2f5cbe3ff87b176e7722cbb58a1f9a58ffcceb394a2bd0b6f3f276aebd2d2b9b85a510dde7755fc8f4fa17e4f63395c631f350ab948516eb8c1f481a1eaf3d57bf7dc002003eacddb68acb13d5de234f5964a6d69b16382fb080c0c572ce1d826085bc3bc27231a3a1e7e1f190e215be228dbc42ff51cca328476e45188b92761dc298d1600782027eca3dccb741a9942c7d045ba288243bf3cb33717639921881e38f297c70ecb0aefed97caf8b663206e637e5c3f0800307f05b679ab7ac6833a5c2b719b03f93894e2dbebf4d4800d89bc790f2e3edd3d4e06086b1efb35ea542bfb6e96e85ba54d6c780978c95948a84c94df2c05ba70682dc63b067fd7b0d56ed45b13850225726b82cd741050ad0b7e555e650d2880142e0f2144e6faa214c9ce285ead0d443d93e9ae113fe4ac25333580eb1420b0dc68f298d3158b69d386385483c7567190837ffb8fed85a6ac57d7949e9470be95bfdccaafafaab752442df010d9cc502a5ee63c7ef3ea10fe8e1cb6a0a12e3633bb38319f2392d926119c9f93ab91e7e660d491235585cc58cd363ba0f9cb86becff14532ec769faf0296c636f2a21ed5dfff26f588bf1a0af5c4378441a8e5eb5cf87d9e7a137cbbe8246a1bbe28b2eea6579d718ab9a53f8bb51baac1ee5923d047742659e14cafec8186359fdf4faebad2562aa70f4ecccd93040a86486cfe1c46052635d71a64ea179bea31b1c2e0a2e644a91bdc01c97e9ebe0b191bd6d7ff555bb9d277839b2c79e4e80c46c9921e9de5b08963897565e3e0923bf6d483815b789a9a1418f71c59c82b6918037a1d4c30ba91fa9157701f51c32506fe27c40fb0744a978722c0ebaeeeb68d176c63925a0094fb60103c306a2d3f018b6668b93d80538052b6b0e20fdd16c63f4eea39a3b2c6a809bba259c60245ec62fb91daf946dae4f943fdf5a4c5e5581a86ec83ca3e37eddc2f05b21e25d8f20a9e78c07e2effe66cd60ebd19d16e88dd9464cebb48948b699fd442b5827b0e1641a47413c99f13bbe5913c45e2da3ce80ef17ef7e0baddd8ac10770e4515f16f1cd3a335bdc5065cf298d0dfd6a3de4ff62eeda79abf551da4d7e916c3a5c5f009021610be64754c92b4d3034c82f81829e863d85e3be23c9a18a1dac57795e189bb07cb27a356623321475dd5d9c41617a1206e0d5eb0e7e89c0d61ea12d0bdb2f3a08a6cd9c185e8abc3381375c4a39ffca40d94253b1f773cacc295cf135a042ee5c4ce5bc6e363ab7269392b4c68e66f67c3218949ba027c0e68eff65bd2f668ea7bf2443327c057379dd22584919be5aae8f17eab5f4e567d1d9beab1335cd4b8202c75405e6e15aa936e6911caa54371ba971149fcd1beb6011f003f780a2ac0b771155a3e834e20b2e7df746543ac6b8450344b7db63aa0b40605256071618ddc9d73fd6902cf97fb4c636afaa1bd02c70ebc15fc309ee6845e3e8bb23f7dfebbda85b893bc34c285c09d2ced9afad3fc59cd192f77d568269e9068aaa702e9b2cc3faf6941bb01e8917467ee54d99b9220f4260b58e84cd65c7997b8741b724c805f9a08b1ef6b6388ab4a912f13144d4f1b47c21f29038fbf3af98f2bfd6294d1c450d3a66a18f1f3c12026fde8b923b86d52dc5bb0532a93440861822bf176ba6c53adeb42d2644e4affb374583e8a800ef65160889f6b453f3081ca48d27c96ca1b0bb97d190fe8c4b44089fca0efba3e84963aa53ac40ada2d1bad3c4aae376e68ac4a10f3ae4af04b875f57ebb034da2fe757ebb0f8e4b102c8c5da83629933007b9c2c64714be5e3b8a9c45ae7a00e72a943bb1931159aa2066164a07d4acfb0017849aee73eff1d37a92d11eb9e27ad21ada31408b6e04a1175e8aa46acd3432aa3114f0fb10e34c1bf5348d693cdc91dff58f13d916177d72a7c242afe17130f217de0dbe04ca5d34e98cf0ff47bc791d6deab0a391699bc0d8458dfe1ab35b0eada324e10cbef68c2873d2e9d064d01258099b81a9e657adb8bb53184c639887463eabc4410e4de02191a46dae8b4db7cd831e76eaa4575cce1ad03239544b4deeaa38e3c9937172bfa1f13189364af23250963f80c3f3fe49a4c987715c335aa63b49e89f0be09a0062694f1ccc856838fcd067a3b6394823c67a55f352f301cb2849ec7a7633eb3c0858f93daff879cc341929f7fa988b379ec04c86c2b71f5d967c09f14e4271d06f6f9e6674595b5deca77ed39b038c4c0a04503a103dda6dc3b6f444ef9d03c1329f97ce35d5c36c2a800230065ad4370ca814a23051e0bfbd295117749a856f5dbac80d9063ed84977ada3a662b0f3854fb95d219104719614f20917e1455e9372e3003e5482621760512587f15ce89feb8a33c116bf7c31bdb33eb6db54e90cb4e0719883f193a489b89972f4881bb05205f6efd08e80b640ef1d4acc9497564ea9e4f00ef66c2bb2ce8ea5e843af866d6433a9f3db1b951876fa649763ba250f91027d8d1f2d9a9a3fe6470f67478723beb0456e1ce7b4ee453b5e023ad21d7757fb7a940ef281e23b3607f6e6ce63d8a40cadaf5c307c5094d3b228c440865e46bbcf046902bdfd75a7a00675ff685a118a6a59179ce32019d068aa000c1a6ee190537f4b9fd98b498722141d1690e1638554dd57e141d4835d7b535248bf6178d66916a0e65d9b46ee9b056b10cf55cb84df1414f6ced488b9f0be8a5cfcddb0b000a61b84fb3d391e6c38c1af57cdbccebee5e1775702a1b050ff461c00518b6c3450488baeba9a7dbfb92910afde9201383e33badbb78096a807e71ec551b25f2099d5933ab43b50f7d82c4be342b17cb65ace747c840f14db27639d90abc2278b38983b0dbc83fe2d4650a7095051d2a1d09f68bbc439da2859f5414e19b1612c8aae119152a10acebdd6677049954dee0575aaabf2880fd1b861eae7e332a3673d6cd0a74321096e56f65746f82b7522c531c58612505bd387415c91fe4c1c41af1ed601f8dae21a3e6b3e1523cc671d0160cdf524da1b07cbfcc114d18f64ed9589b29f87029e11bb82e738e83c43bdde5fca12ecbc85ce272264437376cab6ecbf25f141a5ce137517d6fb0e905884582e26074f447a451a8d9a7005ed4ab0b22cc851c882b074c3b865278865518bbe1436fee52d5406ed0274f4c8001c98e814a785e865efa72d66acbcfc2aa3205fbe5a9dffe5e7bd5ffb5fdc3a3deb1a1d216698a7b477e0fd970698507b63a7a05954e9d4cb0b15043bd39be489df69fe348f6e052ad5d3f00627be33f503a2b3d40b7420e453466f7cdf747526176d521154eab4da53b4c509c8084e584dc335ffe5601725d40eaa4e48562c9a9e347e4fa49858f245930f3b9bca074ca704a9dddbd0a503ee68dda376791345e2ed6f283e644f703b66f771b9b0d7ae4e2d81be80df9935e9523a3858dde77c8ac905c902c6534f987c26bf6ecd87f8e4bfe3f234c7c1d49b175641264c3e7ce74344bae05c79fc9fefac2f5b89ea1fb12e6b330ce97d9aeaa5942c43a587acd4089db6c69fa25face0e600e6e06b32ac26b05035fa39f50d8e9e995125ad90885e249e49412fe6d8fb669673e54f0e245f9213d30c89332569da7f1afc8efadd7486089c6f87c44612bc4111a2964b324652acd4998a18625134cea25f93a09c34ba0a66b84786ad8d8e30732860f6352166322e6501c76fc9099450670ac95c098a9d1e17e3d83cefa3092888b4e691d936bee0484b1137505754f2b44a70a0d8744fa64f9e14b491b1988928d5a4b2a1e700cd7ee215239a090c5ce6276e29df8d5c980623ad44f83f3615f8c5040d282cfc91f8cebd24e18ecbf93e1dcf56b1ed924aaaed1aa137b3669ecd2696e1bcdc06bd0e104110d3810834c74ebf38281de1c1f87f70cc0d4a61824840332c446cfbda7f37c92e69ec5629cc59b5e158a1107b627ade5edbef0b665106b39811470f0c070890ef664885d92500ff474251f56eac69106a1467599c79840320a6dc56932086644c33011503f9a397beb110ececeb20a00ca0e226077630200036fac08273b4f492e87e9813de67f3a16540de56796e229d34486b44e772512e9a2ad83bcfd4aae0ded409f3167399a5a25aeb86b569647e8111d067ac50bef976afaa1729b7d0bdc43aa315bb91f999d26255a18fd7a80fa821546136442fec4fd4e1060330000000000000001f073e00013bfa5f82f45d0024c0809caece86ad257aff66143bd881fb2dfbbc6cc359c4ab16e8c4b4300f61972e27ae6b2cb9c06dce90be90cbf7bb189444341e8c4ece299a43cee6d7ccce5104713dffc7e95ed6ec1fa12c76a6969e20c698f7bf1e844459ebf661c6f74e66563be40d10642ea08570d1e97d8726369375da2721090ded210f4e56188d089c6de1122f29b868245a8b763e431d3dc5f959ac9d84b3f269a616a7e7deff256d1eaee8f12e40f10dae482a49fa5c8f62094b74dc48b828d81f119482c896e3551ec7139b2ac20c510de8c95c7eb94c8d84434b6e320f6c2df8132fc2c04264cd9cdb99f40a39cf763415020298ac98e8d1f83ce834394f2f1cbbca580a30b5dcf37087f5a109e97bfdc900b39a2e9d5d6abc26444239d45a3478ac49670672fcecfb58deb9eed24383e638611a0462c2a5523bd7c9111e040fa0e7ad20d3d51cc5c71268d93da82760551d45943ef8228ca5782a0e0cbbe8c9c75861891eefe956cddee8bb4755a867f491dc43fb57381bb8a092f8efef40813fff591ced33ebecc09c68f6d547a15ccf2e9b331e6e211d63dbc139f36f5678ca362c84906075e353baf1beb01768d52473cb29299fe3d954cc30180a1e548a3e08d261c51235ee4072fc508d7dca458fafea8297e5382bcc1cfdb64ccd1fbbdab56cff4a0891c3e5a61356c286acc21d86b7978842a399f6c2d30abe9e3952bea58bd80f66a6f97a2dda11340bcc41a519edd56b05e1807ee980587c3266582d799c05caeef28aff1dbf9fc409111eb3a28829177617d53c7a53ab7de20c430cfe5c6b143fc8bfd7475f801a9690d1ac3c1074e97ec2336dedeef7294351253b9842eefb531efe47e53d154abfbc98ec848d24eae30ca90809e62841bb3ec11173fdbbbb880192c667399a0eb3259ab08c30369184198476618a4f3928d50ee72f93e5345f8ad2eb93f7dd58886e253d35b1811b6bee2f71eaf3880d4ba2bded739b6ca87819f7e01fd03d586efac80b61fbc2095a54b0685d9ac38659c34b54a5ec3ec24ddf4d56153e2ffe57862120cfa6605ac4cb556c76e0a9c35395baf765811087d4610fb3179ee2ef9fab7c3a90d97b7b6b2492ef532aae62922852706ffc5452d989544ded09a5e72237728e7df9d92a77fe2e0dcf56bf46b29608d2fcac37df13bfdeb13e74d9c20dd38f391139e8c0c83143dac39b6c64cb8fad3de62d611f28978b2885ced749f2659e9c431e55c2525f2df6d17a08c046a68c2eb0383461d96dc322e745053378610f66cdd91a905fca646bb3cd60cb165e926483fc8d130819984a2f92cbc88b5f6230a5923a0c803b4705122e4e776fa529366b27fcf366750807301d29809f99e1b513bd367bffd349d93bf7ba8cf31f89b7c808d1fb4904218efcd41adf4bab934a1630b83610aa6f17c7523d6e35cb55d4916465e579831b5f06d4f1ac8ee16506c2c30540c1b0c1ff594bbe44b34a17a0aba972dc9515a9315637c2412c84575c65fda1cfe53ea283c7014a16729b26539e9139247fd5359236d419451ded76c7a77c23a0fa6bfbe728414c792e265cc38908c418c800e8117cc96e8a36813db7f1167fff02abdbb5ca6b7597b3249c3d5fab614ae71cc7c1c2f5ea57159495d174326f7c98bf22a216d6229f65cf19ef47182b90ad87669a794ab955ec5ab40e6f4d54433a31aa557a3f2f651ff474c08abeb289dff5e4b66a0449ce0bfea576568c4fd3fa7b316f003188304749a880b9ef40de13c2898c72190318e6b1c2361c1168b02ee293f3056a8732637ed2169e799bc7c3bcf2e44a95a4a8c773bed1111d4c18ace7c88d28f737efa36de840ae2ed4884f918d88b02904fb72f3e91630f046e83b94a159ae193d97ca922048fad6b9837a9624f7adc9cbbc01343b33a0a2e361e7fde52e9ea8ee541f2a723ab4c96d4716af2abb503215dc91312172ac09e2b41ee78a63efa2807a9fb31d1bf200e531c0fe990452568c4f9bb354e7fd58ca086ef3ef5993fcd015b123587d7debd8907a3d6b44242805b31bb3929120db2f1b644e19654fdd72e15e0a38f275a1c027b7933411d626ba76146100094203f33484790d964e02dfdf8778206124c9289461df5046d49f2c5466c31eecf1c25c08780bd54c74edc05b93b3520556c8225094d3d5aec362ace3d85d525b03390b01ad65c7202cf8f92c1211f89c8561b412f1f0f84966f8747e06a4375cd769ff6c5f38fc3be12cb0ea1c0a86de66ed2016413e9360229d05a52f6980814eb172665464941be91b164a175e1a8b38121fe12095943dbed37a514fe2454f74c6002cbdb52049a24fc7b747cfcf7d0a0b8a545fcc8f2eb38568dccf457782565144b3ef610c38de74d42de6a1059ae7a45570dace2aca6ef07fcc0be1a1ac5aa93e5a3923ad4b30c6bcc727eeb97c7f54c1a98d0ef3b82f0ba9a832abd9a0e176acc08b663fbc477af4d1a561080c88f9089d4e518a366ee26721e5e9b5e955790ef26dbd150b7e891fb8eec265fe20d05cc3bd4dcc1b79b31830ffcd30fd75d3f1b8220beb5f8332b355d6833c2842903f956037533d787d2a5f6aa454b097e797cadf197ada9da2eafbbc76cb74c3c9d262043bbb483c7f5f63f74e86c9a1faecce89e7e00c52ad1c91c50aee63bb0249fa05c89175a706a4772459d30f017f5a9e74842b5135b9e0ddd733147713841b9b8be1195e4c5414c0353ea1460faba592a405af5f1686c31a9892bbee810656f9cdf45641602566312294e260580b96e183819740922c2a39f1ccca81e539b3dcc88f4ad30000a27d01ef1f23455a7c075d5012d853c080431f2dce9a17aab3cd75349f80a22e7d97318679c3ec59327e07cc654ca374ba9497d0c590a7b1d10200e944510ea41b457196106584a5ecd2811f61b9fc14cb2940548a50af810f0d359d24d19d1c0ab9c3495cb2722ef982351cad33561f3c58e3d9f39bc9290fc7f6214a51814b170633de797157f06a39e90f7d8552e7c098f74847ab4000cf2213165c320049aea984bef0bd5e7f632d33f0a7070590f5caf5825e6d1ef98806079b95f520d8c85439d52d57d7b34aa72103bb02ac03c24e809e0e401d4412bcd880f5fc92e31274e3043e36cedfae5b48ba6f8853de2a668af5f9fde0aab320d57a795ace4859d9e8a572f4608b89e796a9b595b007b6517b09d1dd5afe25eff09ba36a4b0d8b161c2b16670e360b49e772cd23743548d695d6178459fa7d195f18726cd2e59c9892a5d6304644528cfb06367e6b55920277526c88a825d0a52c7437fed3a16e04dfe3de9d0c108f35de708f031a16669961da01565b101542a18513db92f6cb7f1efcb96a16f03bc90b30914fb8f09ab78595266f9c485163645022f217f738e2348a4dbd46e42ba8c106f0051cfccb9ea9e593b5a7029f00a62572b850456ebafc73bd8529f279f2f49a476a79b72dda8e3ab47385369444264b91430b95a346259905a9246eb4098f3fccacce752dbe1c02f60304c252cc31e557356b249b20075b01056c71b99371ff3917eae4fb29c00c39f13f78cfb96ac8e2763ce736232218c88b07c151afb226a8b3a99f21256fc8d832717b6c8d18221fb65b7ceab75329a3260b489ca78ae2eae0c01b68231a8b8786a413ea395611fe4d67f1746c53e56cd98badbf976dd86ee6ccf28249b5e3c4b589b166082a3e785a65973b92881147ca3c8cfbeb54913e6a2fd427b6fbb553bb5ac8721264d486e1a58cb867918dc5810b1b22fa944a74ad8b7038846cf63890c2eeef860f28a5be1d46f84ca5d24d1390ff563621f4d7c0717665cf67fc350ce2e7f4d6e239ac11891a8bfccfd57d48bf3c116b9dfda18f2240a43df0fd37587357eb91c2a5aa8b09a3634b59a85e4f040bf342ac0ff9d516c30ca6416e97aa654b9b73a73eca004e4228a4ab445217c9ebac84b34c3bb9945c81bcaaf17d0ff8da3dc8aef1bb268408a82edf874a31015330c59eac12d8c5125e3b41327f26da6f28f869e2864e88dcbfad39abe569d86460e42d48d95fb887b4f7544a91f50967ab3d6e771ccc75cb3ea8d4fb08d7eb0f5fbb69dcb7ece6fea781a056ce23a4b737257f574a2cbed81c2de7f1abe493609e1dbf591106ed13d3d5d12c5c692759f0b03d86f7b3c7234704be8055bd87cacf0088aee502f8afdf0e8b48e85154fde3f3185b2c56830bb3aa8ac1ef060628997e4e947b60a7416065a16365fbc64813d4e8d68c85b2cef37e529de8291cf0a54dedcfad5ed0f8a2677e98919666a1cac5bf2f23c3142f65e49bea3c4f93398717f80c01d1e1b593842a226193b57c9a6f6cdb0f5750e41db77b4b936056a3e2f93b9d52a8030767c7fbca1a9c4cc088e5104097c7146ed3ba6c2366a7cae345f338feb01086a3693432dcb82d7d92cfb6ef9a4b1434777eb0bed8f901ea86d765293a05fd0420ebc21a78e60479da86c4e43c2717f8fb963b32483869ebd697a8c3c513c382744eca1264a4e3801d35003cc103e13c572ac4fbe2fa2a4260dbc88c60af9eed72e84bad57749bf3a7638f9fc8ee3c17c92e7a3c72c3df99f70ab674ecf9859fa30331cc05932eaec0a2ed952829255029779eacfe33c429c44667cf253b838521da5317faf2fff0bbc60968877024f4bf74aef668173300c49d039bcd89777990864b5249d0c4f9aec9b540e9296c0ceccc85d96d2c8a9851c4eae381af7eea511cb448bc98a47794f07fd78a012e6a78ec65d81584d22647f5c2bff98e5e0d3aa9aef8eea7c4a8dd985f9b683beb5df9081e71303c669288b18c9a19a5b17015fcff77c3a574155fcabf7d598a1808f50ba49301eb36b1a6adc8fde22b425bafd86b061af4b1425f1077bcd15c5cb3b3a452e6e1ad6a8c97d59ac55cebea70b4d9ab8ceda5ccbff25eac4e6e79ca92533b39eae081f02f492f92a768b6986baaeb293287b52915e7e48389a494d36c4e05e82d8268487c950dcf37fa6a17d611c7a9f4465e3ec13791f17cdd7774bdfa4bf550f49a9c1b1bdcf71849ae0235991803f72fc701b394892ab9e423bda93e2d4d1a2374c2b7e394ab00e7f9670d909c5558a5dce677eacb22bb308a4aa2842c29e3f0c2d0947731d39f8420f7bd5677844facc3cfd96ff017ccbf6d4b3f4fc833894879dc34738e8becc91e23166e415609942ea3e361a90a2795cbef1b1a117f097d01f89d0e40cebcc528c1234ea0663b81242018fea202d12d8f5bf12feb4c9e810584e39c7f6808d49c03a29307051549ca17429c16fc11de0c274e2a1b09858943ecdb5cd98a716bab838210fa2ad1918db7527cacee9e6ad5c590f06a10a3c664e59b4bbd06edf459f951ed4a743b16b2a315d9f413d8494d7bd17ba45be16368a2ba283d93461b4b20d423a927b1467632a4214b1ddef218a5823b82096be7c70acd6c644f5f8a17a449f9ba4a662f29e232c5b1d96e562e4b6acafef54698ab2753ae6b044d4582eb425cf0a2bca4b2790968f4aafbf60f7738d1e1373f0946737d8f9edab34b813db03703e4d09e33448953a86ceb932717cbf7a442d2f87f362b8a9b46f0e87101bb802d9db82c3c5de51f8afa9e6c3a558cef0bc9a6609f766d09ce3e02d911e06808019a16df768cd50107d3b37c8cc29dc0f6377d785547217fd0b94aafaf910d02f4f25a26db1d657878eff526d9c571e2ddde39540847640a26246641dd6052ecdec204f64c2408fc9280635e7dcb7ce23ec4c2b9fce07ebcf8d92d6ed3e3441ec04fe6940c528fd0fe7b4a92e3d1055dc954a97fbf2bf1a3c07338534156aa5568a79fe6b4624c0afa36135a9ad07bd1e1a2bb12a79b9ebfede1c0c47f0d33dbc77acf463020003733f9eb34d9a2f404115ef8a7bbdc254a0b8c133b8321b7aaedf1a5c8d34aa25061156d773659446a9f00a72026d08ddb27a331b0a087a7b5a149b7d005d48b6ebd64620fcc9be0c8129224b4c3ed123c38704cfa2fe4e2d8d3346eb51c835f0fd4e106033000000000000000152d26300c08877cb70b78e608110615490fa7768d9b3ea10e663cf38ae183a405858b01431acca946d289109f5408aa2c1114a8fed2620d5aa36d37d8b09ac2c659e7f65fa06b491c6fd2fb8d16e55b6df2bc4b04ec48c07ea88894318c0b5c9f9480bb86185c0d2ccd4e561cb8430ec2d50bcd000ca6665fa037caa56fad5b4111197ec7fbd9ea78a5f42e9e6d93fa3be33cb14e142f75891e516d2ddfb877c39c657470ba7bea9e91d653224226a673a596f2e859221fbc604fa76211e9f470a50e6b6e45b7dbe7689cf9f66103e43dc0debf0c3bf32ae4371bfb4972cd0c8fa33b0a926ca87cca2330d7340a5df548aae5e2b57ce7f6e0b28b569e704708ef6678087119cded40af2c2787509b2680f356679d4e374e7209fc96393b9a127eac72b4154e09d0d09421e0cee230ae39c4d4c730c08382742871541c433c9d55b04962850f0ec74af6702b8377ec28e0ed97f323f803b37058ec2c8d7f12884cfdd2fe27e745486c618c18d6e9a80a897e06c41901028f7a5a1fee44cdde2d48d091f793215f4a78b85874bbb952f02bacdd9234bbec86e2cad13686a35dcf40fadf899ad1d510b73f483b03252d432a7fae38e53bee977abb11ab09dd237f9c9d8e866f59deab0a1f1af69b3ecc6c753d8a84ca9c78c14981633e3e325147b85c0257b286dbb40aa00e7164d0c56c11209f390ec3eab5c78efc9d4c874d808c83e3faabfefd8fe63f834deeedb27894977a9b37ade1b65383e785d339f45a834c56a8d0392ad31273d802eab931bc9e59b7000c8e5813d4f30bbb902192f7d9b39c5c6c8b6c5804507cec262d656c418cd384b85825beea9862ac235fc00b12c1000cbc07ee57d4343080dbe4adb63da361ea2a9e105ae7ee0177e7614c7ef77a652f5a1d60ee7a72bb52cf46b8f56cc4994fcc4204f5b8c1832d8a21b7a69545dc31c194bf144e17ec99bb0faac75771b4296f9d6f00afb8fad0230a91f1c6abf469aa2d0cca8237d48d320c9330ba4fd3dd483289d521469ac02d195ef78f185d3a28c9cd8cf26fee7296566140563738bad57d697f00b53b001d67463ed084fd702010f50f472e820aeb794771c7fa5e9a0cee324cfb8555602826faf116732fca49898ea6f55d191e4d79af7c813f4e69d8d74f6e450f48df3eb9c167c5ff22bcde86930c39a5481a60c139228e285a778d080ac9f807e6d8de752c656fa83b10afd893939c9928d90346271cdc4d0251b4d0ad9c2dc7cd69f3541647c969bac4589ccf5636c9473a46b7a47a8edb148cdbf4b45d793552fff0eaad0d9c15d5bb8c8b5a17bbf0a1e56de1e5236364cd67f1fd503e62d505fb953a55930c64935a3f4e372a5ac5e0577381ecd641837f74264679b6e26e44bb3e035e0697af7696a4b7c925e59cfcfa5065c9c412d295bc51811aa342d4f7941e3eb3764632999701ad1753c6083d571d34272af7ec401b0b62d4ba8aa14b37c7681610ad57878f5f358f2940b5086a78ba48741ca0777315771d2448be59cd08231f61a6cf73a8cdc831a1e829ff23e46987a97622a12839d8c9ef1af20a7560e761284cffdca5c34b09df94e387c069dae24d52db1207814745e98db8330ae66759e4b059a623ccb59b286b187b81b7daf35d7f24c7861693920f1cfabab01eaa0db46ceca5999950fe2741894da966ab0252078672e9f78bcd0a773974d5b8ca367af86b1a33089256a5d29bb84f8f36178b05fa9c2d2022e2aca66af6e5505626ef38ba03111045b37f97657dc6e8b2ec448ff20a831cc3a4e678413efb63621d888239634b6cfe7b3192290d1b49d734ac0dedbe8e6f26bbd8d5afeb8422834b834e705d8af68537b34c9e167e62670dc6c0f5a87d312c4208921877da36d7c20ea2006dac8bc54b9b66457543d5214f1d05d9a4ee2af2db08dda5d0bf95528986f74ec6a1aa7c4a6810690781f78e70f6484ee14494757f03fa8b504ba610137085bd3c7df15ad4681b7f2090320ef6db06bda06f12c660d459d18aabf0bbcce05e89266b82f5d86b372bde0fa652d291146e8899a1e0e06feed4bcfa949514276ef3a8d27c43ee5f29d8bff4b68c9a18e98da3357bbaaf4c4ecc4518d949eeb7da8d93f053430fd8d3aae3b2fbd5333da080fb4c522a6647bbd6e3a7836ab890c380fa599131b627968240d26a48ec320809fba455b0d83931548edd0a712b6f23dac6ac6c7071977864f6d9a454b41c03f1ccf3c5431ed59829ff3488bc6765ecac5ff3ce8da37ed262dc4cf82edc6377a37930d766c350811baeff0181682d0ea1bfe05897b976690122edb13fca19fe9e202b8d93f04cf3dffa8a5d65c5e3ce4adcdcbd35fb16b29b1ceceb6ed40a0ee6e210466381837a2ac86bf2c3ac84b828fba6abf7f3dd638eaafefa63d0ee01b3c0baed62253be7092715de9143599cc3876e88ab804b70d326df8cd01271510bab2109f093c5db8a6557a71c0e6583fd9bf94d6f42119e9ff998b5c217be87ee1102ae472a87172679e3b52033f5696f0782b962faf0d65274155e7ff4aa6093a042d85b3a63eb33ee5c09bb591f0e937fd9f3cf895b93c895270eda8b0d13bf7c31d4664c087386d51747dee7d6aecc40c8fdec03fdfb728ad10741d5519b4656953ba5aa0a37958fdb95281111bf8543f40810e8c65e0451fb105514510e1dfcb7fba4140d2dccf998c42a18eb34eeac72bb9cfde8c92b082085548d372214dfe82471307d59013e3e3e7b17ccc8f3a6caa907af23c6689c997da08780ceee5e619c2a8777bb17656d2fb2e22fc4ef2e28366d57411bb7b9247d92cf28d08f0054957731ab095429da4c7bbd84edf3b1d5f1b28d616c04e711e2d745e4f7ffe436a9c451db9f186461ac893a1f3de4fe98cb4c62cebaa03f1edbc8cb7ed1eecb30b7a3715469c9ec0102ef5d94dfda77b105bb05818ff9fc5f5b08fbfa89d7f2b4c04ee45dbc43bdc8a29f669eccb186ccf165c8b2478eea3ec97f87c2f09b9859b2a14aebf8e2e3539daf6adbc443806ff16c0b487ca6ba7bef673251577854bf73cd9cd6188a2b79b0fad8c926008774aa4bec32a733e8acc6e0547feac456ac1c58d9e33e8a8b951bf6f8518ab47fd9f3a74db6e63065aaa220ca238f3204460457932a80ca02bb9377a42a742d80222eb74c2a9a3cb7a41faadc4abc30b034bac83cd290a4a195c8cc0646c571feb215f2b7ed42f6ae4bd80d126f55853ca04bd8cd69f9c2df9450ab998996c9f26838a9e753a1c49f8535621a1f58a1b1155459b1550aac450165104ea37fb0b0fe3883f6e522b518a10550451609763666b17f05484cfde75bdf7ddaba5951177b7c8b73362cec76da2702307bbbee68b3f7bd45cbbf591c1490c2c1a3f9ffd05cf44eba242745137382d5f55fdac29cee2ba31aca327aecacd575a1261d9896f7d5989dcbb31a2b71d586e2f32bf0794debe4f6d912d3a6323cb1711f69c98ecd950f2c5f7a736b7fd462f00d04e6748423c3e4868585ecc06d11cd61707e1314054c7cb1cf414eed96812ca9b53110296e3cc70fe99618c411c83ff938c13b425aaf11edf4916df79ecd93d2dc55e772aab4d565ecb05a28447e61cbac5120bfc034996bda9a7a1ef0d32db42f5b87a14604949e692213a406ad187d03e4e9bc48b05b377db77255ae6a88d1419fdedca975706d015d03b9e1ffb4842bfe20d4476c5ae1443c98ff8d6c0e06e0ed378f1e3cbb6863a33c64bba731436c1f1891f9b24b1a6ce623abeecd021d663c22357d833c91f4d26dbffc62fea9042ca4e3abef2dd1ffd499f8cafbab5904a5b26de4d61d2552fa080741dbeacc0a8d4f8ae8d8f291ad02ab947d24550d96a5a66dfeb75bb65e4e61d52c6f182b9dd79c5957a783dabe93bd3c80de17e611db68c47abbeecdc369635493bac45ab95fcf648f1a60bb7772c7c5e08f0ba4413c3fd10121a9761babea2b94d4279697430865778931c2c99b69f97670d019fee3653bb17ec19eebc27feb9b73d802b57681684186819a6ff494e58f1ef553dada9291da5890dabef1314e38f316b5fd02134423bb652f8d6946e30680545454788e7a21e4a95057c5e7fcc8e5c8da4ec5e9164fd29f2d8fda77fc7c573c00a9c0c4608b4f466f3f34bf4a3eed2989d740589a1e58d9817b2af1279bf0cfa1dceada907b1327704cef6ffa9b8d488dfc0af7d095ec281c924fd07a6e8b07c913b736c54eeae4382f796c086d683b79f720d3b6424d4a062d1c5377e6eeb5ffd31003bbbf8544e084091d747d3debc0cf868e4447ce9cf0154cc96a4568735002b17707ca835f09be9359dae6d370db3be28c9ca8756aca094f8eb8f53d92aed941d87875ff32c3ae73951fdeb826fd1f0da41e6c2d9955d26812ebf2feb54310066ae3b006a4dc00c479238c6799c9763f02321d2de18cfc43ea30009acafae17733e200fe8d438e092945f23cb21d5b58145f9c94b0181d9de2c6e4c8f2305fabe9cbe4f1a091aee08d86cc81a86698da27e9a41e7bcaf1d0f12692a52b42e3fbc3a425d161074209e80c913135dde51e88ad98181586ebaa580d14fd9d990ac45a82a151539f32bf2d687ba9320167ff41c17471a83f51bef0428d4ac170de897d996c3560c4a0403ce9102a714fbbb82de265291a78817348ab11719ac4522b3b431e5482859537c98d716ca29f3b8c5447ce61bc518aff74e4ba63246ad6e15afb088c7339c3bf6ad034e616168586df24c426936ddb4ff2f7ca5d3bb500c82b5bc9e40416be14256532d6d2af8ec74018a1edef32672e6dcab301eed35725431eef904313307e402ec6c22f4c920cbf5b7f2b13ecb9b38e070d690de95e8889afac5be965ff0bfa8cc94850f163e918cec73f976e724ebd250b6bf090b3401cac1c4b03110a1f333ba14c1d18d4163b317fcbb1e504ac7f5bb4157da03d8d558e2e28ed39b1746543a9de70ad1dc22db5dd30d6fc9105f41835f7ab62f6385d7d6d1c7dabe700343ebb2f3c1bbe3b495d6787304d0054506027ea9bfdab80614bf811212e5afbde6f1b65620d6b8944845ac9558a64a1913269930b6bc157f277eefb1074dc15d82036d4968801facf0d2e7719c8b121790663ffaede7a91a1f4bdb2a83d7336271ee7e996d6721673b18afb4d2472ed31da440b7fd452b1a5b24007dbdf780f9f130fa3b73baca86f2a4be1229ef5d83e8ad3582794ba182553a3566392eec9f7cfcda8c6ddae331fc63e519e273383460edc9e83061a7f70ffe367384c6f54952d0c551e39c321861e3b925fb3ad7c0d2df20874e649aa642a8f9604c2c227a3879e1859e1e238dad258117c2cddf963c7b4831d7564c66a2e30bd6286cc7295da97c5680ef22156e4dee2ca43ac1a1a12a065bbc82838cd81f48c7ba19780225810be3496067fb1e3df473951979a68a5386fb956aca68e2b8f121fe47282d564a6bffafaac66c155e0af643e73abcb7c61467c9f832a2680343ac58760156fcfa0db2f540a221b9d9cc864f53d432521a54f4cb9708bb127c85022078a86a5849f8c5dd2a6fae46980fdbaacb0fb41941fdcb9900ecac65545d286c14e22d5f89fef97dd2133bc20649cb8b68ab81504ab7fa61bf544f94ce7f03f2fb28102e7f7f47fa36368bf1c17fac2c5737eabd07998c923d8970ae3312d5da12a3b46ded0bfc2415020246041e162dde05b14888b536b5b870e109438ae2571f73671cf3b971d5e3145c50813a416a6f6e91c7f93d294af8fd37061f126a6404f98f2fa1dba62716bbebe6fd4b527964b49e2b26581af30836ba8a6a28af460d29d815498f571f63e1643f9806085056c338c6c0ce01caa00a344d0dd6afd946bfa397813196c9992bff90b10000
\ No newline at end of file
diff --git a/tests/data/2in5out_tx.hex b/tests/data/2in5out_tx.hex
new file mode 100644
index 00000000..052bfa20
--- /dev/null
+++ b/tests/data/2in5out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/3in3out_tx.hex b/tests/data/3in3out_tx.hex
new file mode 100644
index 00000000..4a0a7de3
--- /dev/null
+++ b/tests/data/3in3out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/4in3out_tx.hex b/tests/data/4in3out_tx.hex
new file mode 100644
index 00000000..3de2ec43
--- /dev/null
+++ b/tests/data/4in3out_tx.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/elip203_3.hex b/tests/data/elip203_3.hex
new file mode 100644
index 00000000..04b347d5
--- /dev/null
+++ b/tests/data/elip203_3.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/data/elip203_4.hex b/tests/data/elip203_4.hex
new file mode 100644
index 00000000..062c2818
--- /dev/null
+++ b/tests/data/elip203_4.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tests/pset.rs b/tests/pset.rs
deleted file mode 100644
index 1e75e9f9..00000000
--- a/tests/pset.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-#![cfg(all(test, feature = "integration"))]
-
-extern crate elements;
-
-extern crate bitcoin;
-#[cfg(feature = "integration")]
-extern crate elementsd;
-extern crate rand;
-
-use bitcoin::hashes::hex::ToHex;
-use bitcoin::{Address, Amount};
-use elements::bitcoin::hashes::hex::FromHex;
-use elements::bitcoin::hashes::Hash;
-use elements::encode::{deserialize, serialize};
-use elements::pset::PartiallySignedTransaction;
-use elements::Txid;
-use elements::{AssetId, ContractHash, OutPoint};
-use elementsd::bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
-use elementsd::bitcoincore_rpc::RpcApi;
-use elementsd::bitcoind::BitcoinD;
-use elementsd::{bitcoind, ElementsD};
-use rand::distributions::{Distribution, Uniform};
-use std::str::FromStr;
-
-trait Call {
-    fn call(&self, cmd: &str, args: &[Value]) -> Value;
-    fn decode_psbt(&self, psbt: &str) -> Option<Value>;
-    fn get_new_address(&self) -> String;
-    fn get_pegin_address(&self) -> (String, String);
-    fn wallet_create_funded_psbt(&self, address: &str) -> String;
-    fn expected_next(&self, psbt: &str) -> String;
-    fn wallet_process_psbt(&self, psbt: &str) -> String;
-    fn finalize_psbt(&self, psbt: &str) -> String;
-    fn test_mempool_accept(&self, hex: &str) -> bool;
-    fn get_first_prevout(&self) -> OutPoint;
-    fn generate(&self, blocks: u32);
-    fn get_balances(&self) -> Value;
-}
-
-#[test]
-fn tx_unblinded() {
-    let (elementsd, _bitcoind) = setup(false);
-
-    let address = elementsd.get_new_address();
-    let psbt_base64 = elementsd.wallet_create_funded_psbt(&address);
-    assert_eq!(elementsd.expected_next(&psbt_base64), "blinder");
-    psbt_rtt(&elementsd, &psbt_base64);
-}
-
-#[test]
-fn tx_blinded() {
-    let (elementsd, _bitcoind) = setup(false);
-
-    let address = elementsd.get_new_address();
-    let psbt_base64 = elementsd.wallet_create_funded_psbt(&address);
-    assert_eq!(elementsd.expected_next(&psbt_base64), "blinder");
-    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
-    assert_eq!(elementsd.expected_next(&psbt_base64), "finalizer");
-    psbt_rtt(&elementsd, &psbt_base64);
-
-    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
-    assert!(elementsd.test_mempool_accept(&tx_hex));
-}
-
-#[test]
-fn tx_issuance() {
-    let (elementsd, _bitcoind) = setup(false);
-
-    let address_asset = elementsd.get_new_address();
-    let address_reissuance = elementsd.get_new_address();
-    let address_lbtc = elementsd.get_new_address();
-    let prevout = elementsd.get_first_prevout();
-
-    let contract_hash = ContractHash::from_inner([0u8; 32]);
-    let entropy = AssetId::generate_asset_entropy(prevout, contract_hash);
-    let asset_id = AssetId::from_entropy(entropy.clone());
-    let reissuance_id = AssetId::reissuance_token_from_entropy(entropy, true);
-
-    let value = elementsd.call(
-            "createpsbt",
-            &[
-                json!([{ "txid": prevout.txid, "vout": prevout.vout, "issuance_amount": 1000, "issuance_tokens": 1}]),
-                json!([
-                    {address_asset: "1000", "asset": asset_id.to_string(), "blinder_index": 0},
-                    {address_reissuance: "1", "asset": reissuance_id.to_string(), "blinder_index": 0},
-                    {address_lbtc: "20.9", "blinder_index": 0},
-                    {"fee": "0.1" }
-                ]),
-                0.into(),
-                false.into(),
-            ],
-        );
-    let psbt_base64 = value.as_str().unwrap().to_string();
-
-    assert_eq!(elementsd.expected_next(&psbt_base64), "updater");
-    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
-    assert_eq!(elementsd.expected_next(&psbt_base64), "finalizer");
-    psbt_rtt(&elementsd, &psbt_base64);
-
-    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
-    assert!(elementsd.test_mempool_accept(&tx_hex));
-}
-
-#[test]
-#[ignore] // TODO this fails because elements decodepsbt is not printing TxOut::asset (PSET_IN_WITNESS_UTXO)
-fn tx_pegin() {
-    let (elementsd, bitcoind) = setup(true);
-    let bitcoind = bitcoind.unwrap();
-    let btc_addr = bitcoind.client.get_new_address(None, None).unwrap();
-    let address_lbtc = elementsd.get_new_address();
-    bitcoind.client.generate_to_address(101, &btc_addr).unwrap();
-    let (pegin_address, claim_script) = elementsd.get_pegin_address();
-    let address = Address::from_str(&pegin_address).unwrap();
-    let amount = Amount::from_sat(100_000_000);
-    let txid = bitcoind
-        .client
-        .send_to_address(&address, amount, None, None, None, None, None, None)
-        .unwrap();
-    let tx = bitcoind.client.get_raw_transaction(&txid, None).unwrap();
-    let tx_bytes = serialize(&tx);
-    let vout = tx
-        .output
-        .iter()
-        .position(|o| {
-            let addr = Address::from_script(&o.script_pubkey, bitcoin::Network::Regtest);
-            addr.unwrap().to_string() == pegin_address
-        })
-        .unwrap();
-
-    bitcoind.client.generate_to_address(101, &btc_addr).unwrap();
-    let proof = bitcoind.client.get_tx_out_proof(&[txid], None).unwrap();
-    elementsd.generate(2);
-    let inputs = json!([ {"txid":txid, "vout": vout,"pegin_bitcoin_tx": tx_bytes.to_hex(), "pegin_txout_proof": proof.to_hex(), "pegin_claim_script": claim_script } ]);
-    let outputs = json!([
-        {address_lbtc: "0.9", "blinder_index": 0},
-        {"fee": "0.1" }
-    ]);
-    let value = elementsd.call("createpsbt", &[inputs, outputs, 0.into(), false.into()]);
-    let psbt_base64 = value.as_str().unwrap().to_string();
-    assert_eq!(elementsd.expected_next(&psbt_base64), "updater");
-    let psbt_base64 = elementsd.wallet_process_psbt(&psbt_base64);
-    assert_eq!(elementsd.expected_next(&psbt_base64), "extractor");
-
-    psbt_rtt(&elementsd, &psbt_base64);
-
-    let tx_hex = elementsd.finalize_psbt(&rtt(&psbt_base64));
-    assert!(elementsd.test_mempool_accept(&tx_hex));
-}
-
-fn rtt(base64: &str) -> String {
-    base64::encode(serialize(&psbt_from_base64(&base64)))
-}
-
-fn psbt_rtt(elementsd: &ElementsD, base64: &str) {
-    let a = elementsd.decode_psbt(&base64).unwrap();
-
-    let b_psbt = psbt_from_base64(&base64);
-    let mut b_bytes = serialize(&b_psbt);
-    let b_base64 = base64::encode(&b_bytes);
-    let b = elementsd.decode_psbt(&b_base64).unwrap();
-
-    assert_eq!(a, b);
-
-    let mut rng = rand::thread_rng();
-    let die = Uniform::from(0..b_bytes.len());
-    for _ in 0..1_000 {
-        let i = die.sample(&mut rng);
-        // ensuring decode prints all data inside psbt, randomly changing a byte,
-        // if the results is still decodable it should not be equal to initial value
-        b_bytes[i] = b_bytes[i].wrapping_add(1);
-        let base64 = base64::encode(&b_bytes);
-        if let Some(decoded) = elementsd.decode_psbt(&base64) {
-            assert_ne!(a, decoded, "{} with changed byte {}", b_bytes.to_hex(), i);
-        }
-        b_bytes[i] = b_bytes[i].wrapping_sub(1);
-    }
-}
-
-impl Call for ElementsD {
-    fn call(&self, cmd: &str, args: &[Value]) -> Value {
-        self.client().call::<Value>(cmd, args).unwrap()
-    }
-
-    fn decode_psbt(&self, psbt: &str) -> Option<Value> {
-        self.client()
-            .call::<Value>("decodepsbt", &[psbt.into()])
-            .ok()
-    }
-
-    fn get_new_address(&self) -> String {
-        self.call("getnewaddress", &[])
-            .as_str()
-            .unwrap()
-            .to_string()
-    }
-
-    fn get_pegin_address(&self) -> (String, String) {
-        let value = self.call("getpeginaddress", &[]);
-        let mainchain_address = value.get("mainchain_address").unwrap();
-        let mainchain_address = mainchain_address.as_str().unwrap().to_string();
-        let claim_script = value.get("claim_script").unwrap();
-        let claim_script = claim_script.as_str().unwrap().to_string();
-        (mainchain_address, claim_script)
-    }
-
-    fn generate(&self, blocks: u32) {
-        let address = self.get_new_address();
-        let _value = self.call("generatetoaddress", &[blocks.into(), address.into()]);
-    }
-
-    fn wallet_create_funded_psbt(&self, address: &str) -> String {
-        let value = self.call(
-            "walletcreatefundedpsbt",
-            &[json!([]), json!([{address.to_string(): "1"}])],
-        );
-        value.get("psbt").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn expected_next(&self, base64: &str) -> String {
-        let value = self.call("analyzepsbt", &[base64.into()]);
-        value.get("next").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn wallet_process_psbt(&self, base64: &str) -> String {
-        let value = self.call("walletprocesspsbt", &[base64.into()]);
-        value.get("psbt").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn finalize_psbt(&self, base64: &str) -> String {
-        let value = self.call("finalizepsbt", &[base64.into()]);
-        value.get("hex").unwrap().as_str().unwrap().to_string()
-    }
-
-    fn get_first_prevout(&self) -> OutPoint {
-        let value = self.call("listunspent", &[]);
-        let first = value.get(0).unwrap();
-        let txid = first.get("txid").unwrap().as_str().unwrap();
-        let vout = first.get("vout").unwrap().as_u64().unwrap();
-
-        OutPoint::new(Txid::from_hex(txid).unwrap(), vout as u32)
-    }
-    fn get_balances(&self) -> Value {
-        self.call("getbalances", &[])
-    }
-
-    fn test_mempool_accept(&self, hex: &str) -> bool {
-        let result = self.call("testmempoolaccept", &[json!([hex])]);
-        let allowed = result.get(0).unwrap().get("allowed");
-        allowed.unwrap().as_bool().unwrap()
-    }
-}
-
-fn psbt_from_base64(base64: &str) -> PartiallySignedTransaction {
-    let bytes = base64::decode(&base64).unwrap();
-    deserialize(&bytes).unwrap()
-}
-
-fn setup(validate_pegin: bool) -> (ElementsD, Option<BitcoinD>) {
-    let mut bitcoind = None;
-    if validate_pegin {
-        let bitcoind_exe = bitcoind::exe_path().unwrap();
-        let bitcoind_conf = bitcoind::Conf::default();
-        bitcoind = Some(bitcoind::BitcoinD::with_conf(&bitcoind_exe, &bitcoind_conf).unwrap());
-    }
-
-    let conf = elementsd::Conf::new(bitcoind.as_ref());
-
-    let elementsd = ElementsD::with_conf(elementsd::exe_path().unwrap(), &conf).unwrap();
-
-    let create = elementsd.call("createwallet", &["wallet".into()]);
-    assert_eq!(create.get("name").unwrap(), "wallet");
-
-    let rescan = elementsd.call("rescanblockchain", &[]);
-    assert_eq!(rescan.get("stop_height").unwrap(), 0);
-
-    let balances = elementsd.call("getbalances", &[]);
-    let mine = balances.get("mine").unwrap();
-    let trusted = mine.get("trusted").unwrap();
-    assert_eq!(trusted.get("bitcoin").unwrap(), 21.0);
-
-    (elementsd, bitcoind)
-}